ORMFunctionalObjectTest.cpp

Go to the documentation of this file.

#include "ORMFunctionalObjectTest.hpp"

HCE::KVDB_TESTS::Document::Document() {}

const std::string HCE::KVDB_TESTS::Document::json() {
        std::string s_type = Poco::NumberFormatter::format(type);
        items.set("type",s_type);
        items.set("data",item);
        std::ostringstream oss;
        items.stringify(oss);
        data = oss.str();
        return data;
}

void readDocuments(const std::vector<std::string>& vector_file_names, HCE::KVDB_TESTS::Document& doc)
{
    Poco::JSON::Object item;
    Poco::JSON::Array arr;
    for(auto file_name : vector_file_names) {
        Poco::File xml_file(file_name);
        Poco::SharedMemory xml(xml_file, Poco::SharedMemory::AM_READ);

        try
        {
            Poco::XML::DOMParser parser;
            Poco::XML::AutoPtr<Poco::XML::Document> pDoc = parser.parseString(xml.begin());

            Poco::XML::NodeIterator it(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
            Poco::XML::Node* pNode = it.nextNode();
            while (pNode)
            {
                Poco::XML::NamedNodeMap* pmap = pNode->attributes();
                std::string key;
                if(pmap) {
                    for(unsigned i=0; i<pmap->length(); ++i) {
                        Poco::XML::Node* p_node = pmap->item(i);
                        if(p_node->nodeName()=="id") {
                            key = p_node->nodeValue();
                            switch(doc.type) {
                                case HCE::KVDB_TESTS::Document::get :
                                case HCE::KVDB_TESTS::Document::del :
                                case HCE::KVDB_TESTS::Document::check : {
                                    Poco::Dynamic::Var var(key);
                                    arr.add(var);
                                    break;
                                }
                                default: break;
                            }
                        }
                        //std::cout << (pmap->item(i))->nodeName() << ":" << (pmap->item(i))->nodeValue() << std::endl;
                    }
                    //pmap->autoRelease();
                    pmap->release();
                }
                if(doc.type == HCE::KVDB_TESTS::Document::put) {
                if(pNode->nodeName()=="sphinx:document") {
                    std::string value;
                    value = pNode->innerText();
                    item.set(key, value);
                    //std::cout << pNode->innerText() << std::endl;
                }
                }
                //std::cout << pNode->nodeName() << ":" << pNode->nodeValue() << std::endl;
                pNode = it.nextNode();
            }
        }
        catch (Poco::Exception& exc)
        {
            std::cerr << exc.displayText() << std::endl;
        }
    }
    switch(doc.type) {
        case HCE::KVDB_TESTS::Document::put : {
            doc.item.set("documents",item);
            break;
        }
        case HCE::KVDB_TESTS::Document::get :
        case HCE::KVDB_TESTS::Document::del :
        case HCE::KVDB_TESTS::Document::check : {
            doc.item.set("documents",arr);
            break;
        }
        default: break;
    }
}


Poco::SharedPtr<HCE::ORMFunctionalObject> pOrmFuncObj;


TEST(ORMFunctionalObject, init)
{
    HCE::DataBaseDriverConfig db_config;
    db_config.setDataBaseName ("test");
    db_config.setDataBaseUrl (HCE::KVDB_TESTS::URL);
    pOrmFuncObj = Poco::SharedPtr<HCE::ORMFunctionalObject>(new HCE::ORMFunctionalObject(db_config));
}

TEST(ORMFunctionalObjectTest, put_documents)
{
        try {
                HCE::KVDB_TESTS::Document doc;
                doc.type = HCE::KVDB_TESTS::Document::put;
                readDocuments(doc.vector_file_names, doc);
                //std::cout << doc.json() << std::endl;
                #ifdef _DEBUG_
                        std::cout << pOrmFuncObj->processJSON(doc.json()) << std::endl;
                #endif
        }
        catch (const Poco::Exception& ex) {
                std::cout << ex.displayText() << std::endl;
                throw;
        }
}


TEST(ORMFunctionalObjectTest, get_documents_by_id)
{
    HCE::KVDB_TESTS::Document doc;
    doc.type = HCE::KVDB_TESTS::Document::get;
    readDocuments(doc.vector_file_names, doc);
        #ifdef _DEBUG_
        std::cout << doc.json() << std::endl;
        std::cout << pOrmFuncObj->processJSON(doc.json()) << std::endl;
        #endif
}


TEST(ORMFunctionalObjectTest, del_documents_by_id)
{
    HCE::KVDB_TESTS::Document doc;
    doc.type = HCE::KVDB_TESTS::Document::del;
    readDocuments(doc.vector_file_names, doc);
        #ifdef _DEBUG_
        std::cout << doc.json() << std::endl;
        std::cout << pOrmFuncObj->processJSON(doc.json()) << std::endl;
        #endif
}

/*
TEST(ORMFunctionalObjectTest, check_documents_by_id)
{
    Document doc;
    doc.type = Document::check;
    readDocuments(vector_file_names, doc);
//    std::cout << doc.json() << std::endl;
    std::cout << pOrmFuncObj->processJSON(doc.json()) << std::endl;
}

TEST(ORMFunctionalObjectTest, command_not_support)
{
    Document doc;
    doc.type = (a::Document::admin)-1;
    readDocuments(vector_file_names, doc);
    std::cout << doc.json() << std::endl;
    std::cout << pOrmFuncObj->processJSON(doc.json()) << std::endl;
}

TEST(ORMFunctionalObjectTest, invalid_message_type_put)
{
    Document doc;
    doc.type = Document::get;
    readDocuments(vector_file_names, doc);
    doc.type = Document::put;
    std::cout << doc.json() << std::endl;
    std::cout << pOrmFuncObj->processJSON(doc.json()) << std::endl;
}


TEST(ORMFunctionalObjectTest, invalid_message_type_get)
{
    Document doc;
    doc.type = Document::put;
    readDocuments(vector_file_names, doc);
    doc.type = Document::get;
    std::cout << doc.json() << std::endl;
    std::cout << pOrmFuncObj->processJSON(doc.json()) << std::endl;
}


TEST(ORMFunctionalObjectTest, invalid_json)
{
    std::vector<std::string> jsons {
    //Request protocol
    //0 - PUT
    "{\"type\":\"0\",\"data\":{\"documents\":{\"123\":\"content 123\",\"456\":\"content 456\"}}}"
    //1,2,3 - GET, CHECK, DELETE
    , "\{\"type\":\"1\",\"data\":{\"documents\":[\"123\",\"456\"]}}"

    //Response protocol
    //0, 2, 3 - PUT, DELETE, CHECK
    , "{\"error_code\":\"0\",\"error_message\":\"\",\"data\":{\"documents\":{\"123\":\"0\",\"456\":\"0\"}},\"time\":\"1\"}"
    //1 - GET
    , "{\"error_code\":\"0\",\"error_message\":\"\",\"data\":{\"documents\":{\"123\":\"content 123\",\"456\":\"content 456\"}}\",\"time\":\"1\"}"

    //wrong json
    , "{\"error_code\":\"0\",\"error_message\":\"\",\"data\":{\"documents\":{\"123\":\"content 123\"\"456\":\"content 456\"}}\",\"time\":\"1\"}"
    };
    for(auto json:jsons) {
        std::cout << pOrmFuncObj->processJSON(json) << std::endl;
    }
}
*/