catalog/tests/unit-tests/query/test-query-adapter.cpp

/** NDN-Atmos: Cataloging Service for distributed data originally developed
 *  for atmospheric science data
 *  Copyright (C) 2015 Colorado State University
 *
 *  NDN-Atmos is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  NDN-Atmos 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NDN-Atmos.  If not, see <http://www.gnu.org/licenses/>.
**/

#include "query/query-adapter.hpp"
#include "boost-test.hpp"
#include "../../unit-test-time-fixture.hpp"
#include "util/config-file.hpp"

#include <boost/mpl/list.hpp>
#include <boost/thread.hpp>
#include <ndn-cxx/util/dummy-client-face.hpp>
#include <boost/property_tree/info_parser.hpp>

namespace atmos{
namespace tests{
  using ndn::util::DummyClientFace;
  using ndn::util::makeDummyClientFace;

  class QueryAdapterTest : public query::QueryAdapter<std::string>
  {
  public:
    QueryAdapterTest(const std::shared_ptr<ndn::util::DummyClientFace>& face,
                     const std::shared_ptr<ndn::KeyChain>& keyChain,
                     const std::shared_ptr<chronosync::Socket>& syncSocket)
      : query::QueryAdapter<std::string>(face, keyChain, syncSocket)
    {
    }

    virtual
    ~QueryAdapterTest()
    {
    }

    void setDatabaseTable(const std::string& databaseTable)
    {
      m_databaseTable.assign(databaseTable);
    }

    void setNameFields(const std::vector<std::string>& nameFields)
    {
      m_nameFields = nameFields;
    }

    void setPrefix(const ndn::Name& prefix)
    {
      m_prefix = prefix;
    }

    void setSigningId(const ndn::Name& signingId)
    {
      m_signingId = signingId;
    }

    const ndn::Name
    getPrefix()
    {
      return m_prefix;
    }

    const ndn::Name
    getSigningId()
    {
      return m_signingId;
    }

    std::shared_ptr<ndn::Data>
    getAckData(std::shared_ptr<const ndn::Interest> interest, const ndn::Name::Component& version)
    {
      return makeAckData(interest, version);
    }

    std::shared_ptr<ndn::Data>
    getReplyData(const ndn::Name& segmentPrefix,
                 const Json::Value& value,
                 uint64_t segmentNo,
                 bool isFinalBlock,
                 bool isAutocomplete,
                 uint64_t resultCount,
                 uint64_t viewStart,
                 uint64_t viewEnd)
    {
      return makeReplyData(segmentPrefix, value, segmentNo, isFinalBlock,
                           isAutocomplete, resultCount, viewStart, viewEnd, false);
    }

    void
    queryTest(std::shared_ptr<const ndn::Interest> interest)
    {
      runJsonQuery(interest);
    }

    void
    prepareSegmentsByParams(std::vector<std::pair<std::string, std::string>>& queryParams,
                            const ndn::Name& segmentPrefix)
    {
      //BOOST_CHECK_EQUAL(sqlString, "SELECT name FROM cmip5 WHERE name=\'test\';");
      for (auto it = queryParams.begin() ; it != queryParams.end(); ++it) {
        std::cout << it->first << " " << it->second << std::endl;
      }

      Json::Value fileList;
      fileList.append("/ndn/test1");
      fileList.append("/ndn/test2");
      fileList.append("/ndn/test3");

      std::shared_ptr<ndn::Data> data = makeReplyData(segmentPrefix,
                                                      fileList, 0, true, false,
                                                      3, 0, 2, true);
      m_mutex.lock();
      m_cache.insert(*data);
      m_mutex.unlock();
    }

    std::shared_ptr<const ndn::Data>
    getDataFromCache(const ndn::Interest& interest)
    {
      return m_cache.find(interest);
    }

    void
    configAdapter(const util::ConfigSection& section,
                  const ndn::Name& prefix)
    {
      onConfig(section, false, std::string("test.txt"), prefix);
    }

    bool
    json2AutocompletionSqlTest(std::stringstream& sqlQuery,
                               Json::Value& jsonValue,
                               bool& lastComponent,
                               std::stringstream& nameField)
    {
      return json2AutocompletionSql(sqlQuery, jsonValue, lastComponent, nameField);
    }

    bool
    testDoPrefixBasedSearch(Json::Value& jsonValue,
                            std::vector<std::pair<std::string, std::string>>& typedComponents)
    {
      return doPrefixBasedSearch(jsonValue, typedComponents);
    }

    bool
    testDoFilterBasedSearch(Json::Value& jsonValue,
                            std::vector<std::pair<std::string, std::string>>& typedComponents)
    {
      return doFilterBasedSearch(jsonValue, typedComponents);
    }


  };

  class QueryAdapterFixture : public UnitTestTimeFixture
  {
  public:
    QueryAdapterFixture()
      : face(makeDummyClientFace(io))
      , keyChain(new ndn::KeyChain())
      , databaseTable("cmip5")
      , queryAdapterTest1(face, keyChain, syncSocket)
      , queryAdapterTest2(face, keyChain, syncSocket)
    {
      std::string c1("activity"), c2("product"), c3("organization"), c4("model");
      std::string c5("experiment"), c6("frequency"), c7("modeling_realm"), c8("variable_name");
      std::string c9("ensemble"), c10("time");
      nameFields.push_back(c1);
      nameFields.push_back(c2);
      nameFields.push_back(c3);
      nameFields.push_back(c4);
      nameFields.push_back(c5);
      nameFields.push_back(c6);
      nameFields.push_back(c7);
      nameFields.push_back(c8);
      nameFields.push_back(c9);
      nameFields.push_back(c10);

      queryAdapterTest1.setDatabaseTable(databaseTable);
      queryAdapterTest1.setNameFields(nameFields);
      queryAdapterTest2.setDatabaseTable(databaseTable);
      queryAdapterTest2.setNameFields(nameFields);
    }

    virtual
    ~QueryAdapterFixture()
    {
    }

  protected:
    void
    initializeQueryAdapterTest1()
    {
      util::ConfigSection section;
      try {
        std::stringstream ss;
        ss << "signingId /test/signingId\
             filterCategoryNames activity,product,organization,model,experiment,frequency,modeling_realm,variable_name,ensemble\
             database                   \
             {                          \
              dbServer localhost        \
              dbName testdb             \
              dbUser testuser           \
              dbPasswd testpwd          \
             }";
        boost::property_tree::read_info(ss, section);
      }
      catch (boost::property_tree::info_parser_error &e) {
        std::cout << "Failed to read config file " << e.what() << std::endl;;
      }

      queryAdapterTest1.configAdapter(section, ndn::Name("/test"));
    }

    void
    initializeQueryAdapterTest2()
    {
      util::ConfigSection section;
      try {
        std::stringstream ss;
        ss << "\
             filterCategoryNames activity,product,organization,model,experiment,frequency,modeling_realm,variable_name,ensemble\
             database\
             {                                  \
              dbServer localhost                \
              dbName testdb                     \
              dbUser testuser                   \
              dbPasswd testpwd                  \
             }";
        boost::property_tree::read_info(ss, section);
      }
      catch (boost::property_tree::info_parser_error &e) {
        std::cout << "Failed to read config file " << e.what() << std::endl;;
      }

      queryAdapterTest2.configAdapter(section, ndn::Name("/test"));
    }

  protected:
    std::shared_ptr<DummyClientFace> face;
    std::shared_ptr<ndn::KeyChain> keyChain;
    std::shared_ptr<chronosync::Socket> syncSocket;
    std::string databaseTable;
    std::vector<std::string> nameFields;
    QueryAdapterTest queryAdapterTest1;
    QueryAdapterTest queryAdapterTest2;
  };

  BOOST_FIXTURE_TEST_SUITE(QueryAdapterTestSuite, QueryAdapterFixture)

  BOOST_AUTO_TEST_CASE(BasicQueryAdapterTest1)
  {
    BOOST_CHECK(queryAdapterTest1.getPrefix() == ndn::Name());
    BOOST_CHECK(queryAdapterTest1.getSigningId() == ndn::Name());
  }

  BOOST_AUTO_TEST_CASE(BasicQueryAdapterTest2)
  {
    initializeQueryAdapterTest1();
    BOOST_CHECK(queryAdapterTest1.getPrefix() == ndn::Name("/test"));
    BOOST_CHECK(queryAdapterTest1.getSigningId() == ndn::Name("/test/signingId"));
  }

  // use real data instead of ack data
  BOOST_AUTO_TEST_CASE(QueryAdapterMakeAckDataTest)
  {
    ndn::Interest interest(ndn::Name("/test/ack/data/json"));
    interest.setInterestLifetime(ndn::time::milliseconds(1000));
    interest.setMustBeFresh(true);
    std::shared_ptr<const ndn::Interest> interestPtr = std::make_shared<ndn::Interest>(interest);

    const ndn::name::Component version
      = ndn::name::Component::fromVersion(1);

    std::shared_ptr<ndn::Data> data = queryAdapterTest2.getAckData(interestPtr, version);
    BOOST_CHECK_EQUAL(data->getName().toUri(), "/test/ack/data/json");
  }

  BOOST_AUTO_TEST_CASE(QueryAdapterMakeReplyDataTest1)
  {
    Json::Value fileList;
    fileList.append("/ndn/test1");
    fileList.append("/ndn/test2");

    const ndn::Name prefix("/atmos/test/prefix");

    std::shared_ptr<ndn::Data> data = queryAdapterTest2.getReplyData(prefix, fileList,
                                                                     1, false, false, 2, 0, 1);
    BOOST_CHECK_EQUAL(data->getName().toUri(), "/atmos/test/prefix/%00%01");
    BOOST_CHECK_EQUAL(data->getFinalBlockId(), ndn::Name::Component(""));
    const std::string jsonRes(reinterpret_cast<const char*>(data->getContent().value()),
                              data->getContent().value_size());
    Json::Value parsedFromString;
    Json::Reader reader;
    BOOST_CHECK_EQUAL(reader.parse(jsonRes, parsedFromString), true);
    BOOST_CHECK_EQUAL(parsedFromString["resultCount"], 2);
    BOOST_CHECK_EQUAL(parsedFromString["results"].size(), 2);
    BOOST_CHECK_EQUAL(parsedFromString["results"][0], "/ndn/test1");
    BOOST_CHECK_EQUAL(parsedFromString["results"][1], "/ndn/test2");
  }

  BOOST_AUTO_TEST_CASE(QueryAdapterMakeReplyDataTest2)
  {
    Json::Value fileList;
    fileList.append("/ndn/test1");
    const ndn::Name prefix("/atmos/test/prefix");

    std::shared_ptr<ndn::Data> data = queryAdapterTest2.getReplyData(prefix, fileList,
                                                                     2, true, true, 1, 0, 0);

    BOOST_CHECK_EQUAL(data->getName().toUri(), "/atmos/test/prefix/%00%02");
    BOOST_CHECK_EQUAL(data->getFinalBlockId(), ndn::Name::Component::fromSegment(2));
    const std::string jsonRes(reinterpret_cast<const char*>(data->getContent().value()),
                              data->getContent().value_size());
    Json::Value parsedFromString;
    Json::Reader reader;
    BOOST_CHECK_EQUAL(reader.parse(jsonRes, parsedFromString), true);
    BOOST_CHECK_EQUAL(parsedFromString["resultCount"], 1);
    BOOST_CHECK_EQUAL(parsedFromString["next"].size(), 1);
    BOOST_CHECK_EQUAL(parsedFromString["next"][0], "/ndn/test1");
  }

  BOOST_AUTO_TEST_CASE(QueryAdapterQueryProcessTest)
  {
    initializeQueryAdapterTest2();
    Json::Value query;
    query["name"] = "test";
    Json::FastWriter fastWriter;
    std::string jsonMessage = fastWriter.write(query);
    jsonMessage.erase(std::remove(jsonMessage.begin(), jsonMessage.end(), '\n'), jsonMessage.end());
    std::shared_ptr<ndn::Interest> queryInterest
      = std::make_shared<ndn::Interest>(ndn::Name("/test/query").append(jsonMessage.c_str()));

    queryAdapterTest2.queryTest(queryInterest);

    // TODO: the code below should be enabled when queryAdapter can get the correct the
    // ChronoSync state; currently, we don't need the activeQuery to save the ACK data;
    //auto ackData = queryAdapterTest2.getDataFromActiveQuery(jsonMessage);
    //
    //BOOST_CHECK(ackData);
    //if (ackData) {
    //  BOOST_CHECK_EQUAL(ackData->getName().getPrefix(3),
    //  ndn::Name("/test/query/%7B%22name%22%3A%22test%22%7D"));
    //  BOOST_CHECK_EQUAL(ackData->getName().at(ackData->getName().size() - 1),
    //                    ndn::Name::Component("OK"));
    //  BOOST_CHECK_EQUAL(ackData->getContent().value_size(), 0);
    //}

    // there is no query-results namespace data
    auto replyData = queryAdapterTest2.getDataFromCache(*queryInterest);
    BOOST_CHECK(replyData);
    if (replyData){
      BOOST_CHECK_EQUAL(replyData->getName().getPrefix(2), ndn::Name("/test/query"));
      const std::string jsonRes(reinterpret_cast<const char*>(replyData->getContent().value()),
                                replyData->getContent().value_size());
      Json::Value parsedFromString;
      Json::Reader reader;
      BOOST_CHECK_EQUAL(reader.parse(jsonRes, parsedFromString), true);
      BOOST_CHECK_EQUAL(parsedFromString["resultCount"], 3);
      BOOST_CHECK_EQUAL(parsedFromString["results"].size(), 3);
      BOOST_CHECK_EQUAL(parsedFromString["results"][0], "/ndn/test1");
      BOOST_CHECK_EQUAL(parsedFromString["results"][1], "/ndn/test2");
      BOOST_CHECK_EQUAL(parsedFromString["results"][2], "/ndn/test3");
    }
  }

  BOOST_AUTO_TEST_CASE(QueryAdapterAutocompletionSqlSuccessTest)
  {
    initializeQueryAdapterTest2();

    std::stringstream ss, nameField;
    Json::Value testJson;
    bool lastComponent = false;
    testJson["?"] = "/";
    BOOST_CHECK_EQUAL(true,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));
    BOOST_CHECK_EQUAL(lastComponent, false);
    BOOST_CHECK_EQUAL(";", ss.str());
    BOOST_CHECK_EQUAL("activity", nameField.str());

    ss.str("");
    ss.clear();
    nameField.str("");
    nameField.clear();
    testJson.clear();
    testJson["?"] = "/Activity/";
    BOOST_CHECK_EQUAL(true,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));
    BOOST_CHECK_EQUAL(lastComponent, false);
    BOOST_CHECK_EQUAL(" WHERE activity='Activity';", ss.str());
    BOOST_CHECK_EQUAL("product", nameField.str());

    ss.str("");
    ss.clear();
    nameField.str("");
    nameField.clear();
    testJson.clear();
    testJson["?"] = "/Activity/Product/Organization/Model/Experiment/";
    BOOST_CHECK_EQUAL(true,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));
    BOOST_CHECK_EQUAL(lastComponent, false);
    BOOST_CHECK_EQUAL(" WHERE activity='Activity' AND \
experiment='Experiment' AND model='Model' AND organization='Organization' AND product='Product';",
     ss.str());
    BOOST_CHECK_EQUAL("frequency", nameField.str());

    ss.str("");
    ss.clear();
    nameField.str("");
    nameField.clear();
    testJson.clear();
    testJson["?"] = "/Activity/Product/Organization/Model/Experiment/Frequency/Modeling/\
Variable/Ensemble/";
    BOOST_CHECK_EQUAL(true,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));
    BOOST_CHECK_EQUAL(lastComponent, true);
    BOOST_CHECK_EQUAL(" WHERE activity='Activity' AND ensemble=\
'Ensemble' AND experiment='Experiment' AND frequency='Frequency' AND model='Model' AND \
modeling_realm='Modeling' AND organization='Organization' AND product='Product' AND variable_name=\
'Variable';",ss.str());
    BOOST_CHECK_EQUAL("time", nameField.str());
  }

  BOOST_AUTO_TEST_CASE(QueryAdapterAutocompletionSqlFailTest)
  {
    initializeQueryAdapterTest2();

    std::stringstream ss, nameField;
    Json::Value testJson;
    bool lastComponent = false;
    testJson["?"] = "serchTest";
    BOOST_CHECK_EQUAL(false,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));

    ss.str("");
    ss.clear();
    nameField.str("");
    nameField.clear();
    testJson.clear();
    testJson["?"] = "/cmip5";
    BOOST_CHECK_EQUAL(false,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));

    ss.str("");
    ss.clear();
    nameField.str("");
    nameField.clear();
    Json::Value testJson2; //simply clear does not work
    testJson2[0] = "test";
    BOOST_CHECK_EQUAL(false,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));

    ss.str("");
    ss.clear();
    nameField.str("");
    nameField.clear();
    Json::Value testJson3;
    testJson3 = Json::Value(Json::arrayValue);
    BOOST_CHECK_EQUAL(false,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));

    ss.str("");
    ss.clear();
    nameField.str("");
    nameField.clear();
    Json::Value testJson4;
    Json::Value param;
    param[0] = "test";
    testJson4["name"] = param;
    BOOST_CHECK_EQUAL(false,
                      queryAdapterTest2.json2AutocompletionSqlTest(ss,
                                                                   testJson,
                                                                   lastComponent,
                                                                   nameField));
  }

  BOOST_AUTO_TEST_CASE(QueryAdapterDoFilterBasedSearchTest)
  {
    Json::Value testJson;
    testJson["activity"] = "testActivity";
    testJson["product"] = "testProduct";

    std::vector<std::pair<std::string, std::string>> resultComponents;

    BOOST_CHECK_EQUAL(true, queryAdapterTest1.testDoFilterBasedSearch(testJson, resultComponents));
    BOOST_CHECK_EQUAL(2, resultComponents.size());
    for (auto it=resultComponents.begin(); it != resultComponents.end(); it++) {
      if (it->first == "activity")
        BOOST_CHECK_EQUAL(it->second, "testActivity");
      if (it->first == "product")
        BOOST_CHECK_EQUAL(it->second, "testProduct");
    }

    testJson.clear();
    resultComponents.clear();

    BOOST_CHECK_EQUAL(true, queryAdapterTest1.testDoFilterBasedSearch(testJson, resultComponents));
    BOOST_CHECK_EQUAL(0, resultComponents.size());

    testJson.clear();
    resultComponents.clear();

    testJson["name"] = Json::nullValue;
    BOOST_CHECK_EQUAL(false, queryAdapterTest1.testDoFilterBasedSearch(testJson, resultComponents));

    testJson.clear();
    resultComponents.clear();
    Json::Value param;
    param[0] = "test";
    testJson["name"] = param;

    BOOST_CHECK_EQUAL(false, queryAdapterTest1.testDoFilterBasedSearch(testJson, resultComponents));

    testJson.clear();
    resultComponents.clear();
    Json::Value tmp;
    tmp[0] = "test";

    BOOST_CHECK_EQUAL(false, queryAdapterTest1.testDoFilterBasedSearch(tmp, resultComponents));
  }

  BOOST_AUTO_TEST_CASE(QueryAdapterDoPrefixBasedSearchTest)
  {
    Json::Value testJson;
    testJson["??"] = "/";

    std::vector<std::pair<std::string, std::string>> resultComponents;

    BOOST_CHECK_EQUAL(true, queryAdapterTest2.testDoPrefixBasedSearch(testJson, resultComponents));
    BOOST_CHECK_EQUAL(0, resultComponents.size());

    testJson.clear();
    resultComponents.clear();

    testJson["??"] = "/Activity/Product";
    BOOST_CHECK_EQUAL(true, queryAdapterTest2.testDoPrefixBasedSearch(testJson, resultComponents));
    BOOST_CHECK_EQUAL(2, resultComponents.size());

    for (auto it=resultComponents.begin(); it != resultComponents.end(); it++) {
      if (it->first == "activity")
        BOOST_CHECK_EQUAL(it->second, "Activity");
      if (it->first == "product")
        BOOST_CHECK_EQUAL(it->second, "Product");
    }

    testJson.clear();
    resultComponents.clear();

    testJson["??"] = "";
    BOOST_CHECK_EQUAL(false, queryAdapterTest2.testDoPrefixBasedSearch(testJson, resultComponents));

    testJson.clear();
    resultComponents.clear();

    testJson = Json::Value(Json::arrayValue);
    BOOST_CHECK_EQUAL(false, queryAdapterTest2.testDoPrefixBasedSearch(testJson, resultComponents));

    testJson.clear();
    resultComponents.clear();

    Json::Value tmp;
    tmp[0] = "test";
    BOOST_CHECK_EQUAL(false, queryAdapterTest2.testDoPrefixBasedSearch(tmp, resultComponents));

    testJson.clear();
    resultComponents.clear();

    Json::Value param, testJson2;
    param[0] = "test";
    testJson2["activity"] = param;
    BOOST_CHECK_EQUAL(false, queryAdapterTest2.testDoPrefixBasedSearch(testJson2, resultComponents));
  }

  BOOST_AUTO_TEST_SUITE_END()

}//tests
}//atmos