logDigest/testSetup.cpp at master · jarbassaidai/logDigest · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include "testSetup.h"


testSetup::testSetup()
{
   signal(SIGSEGV,&testSetup::signalCatch);

   t_spSL elogSU = structuredLogger::getInstance(ELOGNAME,(t_loggingStyle) (allInfoFile| tokenMsg | sepErrorFile | sepDebugFile));

   m_connectString ="user=postgres host=192.168.81.194 password=m0r3p0w3r";
       genericTable *mp_gtab = new genericTable(m_connectString);
    std::string n1 = ELOGNAME;
    mp_gtab->setLog(n1);
    BOOST_REQUIRE_EQUAL(mp_gtab->connected(),true);
    std::string dropt ("drop table IF EXISTS \"logDigestUnitTest10\" ;");
    std::string cdb( " \
    CREATE DATABASE \"logDigestUnitTest10\" \
    WITH OWNER = postgres    \
       ENCODING = \'UTF8\'  \
       TABLESPACE = pg_default \
       LC_COLLATE = \'en_US.UTF-8\' \
       LC_CTYPE = \'en_US.UTF-8\' \
       CONNECTION LIMIT = -1; \
        ");
    std::string ctable(
    "CREATE TABLE \"hardware_id\" \
    ( \
    \"hwid\" serial, \
    \"make\" character varying, \
    \"revision\" character varying, \
    \"model\" character varying, \
    \"serialnum\" character varying, \
    \"date\" time without time zone, \
    \"description\" character varying, \
    \"ownerid\" integer, \
    CONSTRAINT hwidpk PRIMARY KEY (hwid) \
    );" );

    try{
        pqxx::result r = mp_gtab->nontransQuery(nullptr,dropt);
        r = mp_gtab->nontransQuery(nullptr,cdb);
        delete mp_gtab;
        mp_gtab = nullptr;
        m_connectString += " dbname=logDigestUnitTest10";
        mp_gtab = new genericTable(m_connectString);
        r = mp_gtab->nontransQuery(nullptr,ctable);
        BOOST_CHECK_EQUAL(0,r.size());

    }
    catch (const pqxx::sql_error &e)
    {
        std::string msg = e.query() + e.what();
        elogSU->errorL(critical,msg.c_str());
    }
    catch (std::exception &e) {
        elogSU->errorL(critical,e.what());
        elogSU->stack_trace("crash & burn");
    }


        delete mp_gtab;
        mp_gtab = nullptr;


    BOOST_TEST_MESSAGE("setup genericTable");
}

testSetup::~testSetup()
{

    m_connectString ="user=postgres host=192.168.81.194 password=m0r3p0w3r";
    mp_gtab = new genericTable(m_connectString);
    std::string n=ELOGNAME;
    mp_gtab->setLog(n);
    BOOST_REQUIRE_EQUAL(mp_gtab->connected(),true);

    std::string ddb("DROP DATABASE \"logDigestUnitTest10\" ; ");
    try {
        pqxx::result r = mp_gtab->nontransQuery(nullptr,ddb);
        BOOST_TEST_MESSAGE("teardown genericTable");
    }
    catch (const pqxx::sql_error &e)
    {
        std::string msg = e.query() + e.what();
        elog()->errorL(critical,msg.c_str());
    }


        delete mp_gtab;
        mp_gtab = nullptr;
        elog().reset();

}


 genericTable * testSetup::getinstance()
{

    return  mp_gtab;
}

void testSetup::signalCatch(int sigNum) {
    ///t_spSL elog = structuredLogger::getInstance(ELOGNAME,(t_loggingStyle) (allInfoFile| tokenMsg | sepErrorFile | sepDebugFile));
    ///elog->stack_trace("crash & burn");
    ///elog.reset();
    std::cout << stackTrace().str() ;
}
/**
** to test the protected funtions storeValue writeStored setup needs to
** be a supper class
*/

void testSetup::test_storeValue_writeStored() {

    connectDatabase(m_connectString);
    std::string n1 = ELOGNAME;
    setLog(n1);
    std::string tablename="hardware_id";
    selectTable(tablename);
    storeValue(1,(void*) "chevy");        // make
    storeValue(4,(void*) "2oaiueroiwuer234");// serial number
    std::vector<std::string> fieldsToWrite = { "make", "serialnum"};
    pqxx::result r;
    try {
        writeStored(nullptr,fieldsToWrite);
        std::string query = "select make,serialnum from hardware_id; ";
        r = execQuery(nullptr,query);

    }catch (const pqxx::sql_error &e)
    {
        std::string msg = e.query() + e.what();
        elog()->errorL(critical,msg.c_str());
    }
    std::map<std::string,std::string> valuesToCompare {{"make","chevy"},{"serialnum","2oaiueroiwuer234"}};

   for (pqxx::result::const_iterator row = r.begin();
        row != r.end(); row++)
    {
          for (pqxx::result::tuple::const_iterator fields = row->begin();
            fields != row->end();
            fields++)
            {
                std::string cv = valuesToCompare[fields->name()];
                std::string sv = fields->c_str();
                //std::cout << cv << " " << sv << std::endl;
                BOOST_CHECK_EQUAL(cv.compare(sv),0);

            }
    }


    mp_dbc->disconnect();
    mp_wdbc = nullptr;
    delete mp_dbc;
    mp_dbc=nullptr;
    elog().reset();
}