summaryrefslogtreecommitdiffstats
path: root/test/elog_errorwrap_test.hpp
blob: 7c673b6369c97f37effd115f1a3bd86b18c9fa70 (plain)
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
#include "log_manager.hpp"
#include "xyz/openbmc_project/Common/error.hpp"
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <sdbusplus/bus.hpp>
#include <experimental/filesystem>
#include <phosphor-logging/elog.hpp>
#include <phosphor-logging/log.hpp>
#include <phosphor-logging/elog-errors.hpp>
#include "elog_serialize.hpp"
#include "config.h"

namespace phosphor
{
namespace logging
{
namespace internal
{

namespace fs = std::experimental::filesystem;

class journalInterface
{
    public:
        virtual void journalSync() = 0;
        virtual int sd_journal_open(sd_journal** j, int k) = 0;
        virtual int sd_journal_get_data(sd_journal* j,
                                        const char* transactionIdVar,
                                        const void** data,
                                        size_t length) = 0;
        virtual void sd_journal_close(sd_journal* j) = 0;
};

class journalImpl : public journalInterface
{
    public:
        void journalSync();
        int sd_journal_open(sd_journal** j, int k);
        int sd_journal_get_data(sd_journal* j,
                                const char* transactionIdVar,
                                const void** data,
                                size_t length);
        void sd_journal_close(sd_journal* j);
};



int journalImpl::sd_journal_open(sd_journal** j, int k)
{
    return 1;
}

void journalImpl::journalSync()
{
    return;
}

int journalImpl::sd_journal_get_data(sd_journal* j,
                                     const char* transactionIdVar,
                                     const void** data,
                                     size_t length)
{
    return 1;
}

void journalImpl::sd_journal_close(sd_journal* j)
{
    return;
}


class  MockJournal : public Manager
{
    public:
        MockJournal(sdbusplus::bus::bus& bus,
                    const char* objPath): Manager(bus, objPath) {};
        MOCK_METHOD0(journalSync, void());
        MOCK_METHOD2(sd_journal_open, int(sd_journal**, int));
        MOCK_METHOD4(sd_journal_get_data, int(sd_journal*,
                                              const char*,
                                              const void**, size_t));
        MOCK_METHOD1(sd_journal_close, void(sd_journal*));
};



class TestLogManager : public testing::Test
{
    public:
        sdbusplus::bus::bus bus;
        MockJournal manager;
        TestLogManager()
            : bus(sdbusplus::bus::new_default()),
              manager(bus, "/xyz/openbmc_test/abc")
        {
            fs::create_directories(ERRLOG_PERSIST_PATH);
        }

        ~TestLogManager()
        {
            fs::remove_all(ERRLOG_PERSIST_PATH);
        }

};


}// nmaespace internal
}// namespace logging
}// namespace phosphor
OpenPOWER on IntegriCloud