~aleteoryx/muditaos

ref: b4568c32eb2a4b37e9dfbbe08c446430eee2145c muditaos/module-services/service-db/test/test-service-db-quotes.hpp -rw-r--r-- 5.2 KiB
b4568c32 — Kuba Kleczkowski [MOS-977] Added VoLTE support in additional countries 2 years ago 
                                                                                
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

// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#pragma once

#include <service-db/QuotesMessages.hpp>
#include <service-db/agents/quotes/QuotesAgent.hpp>
#include <service-db/agents/settings/SystemSettings.hpp>

namespace Quotes
{
    class QuotesAgentTester : public QuotesAgent
    {
      public:
        QuotesAgentTester(Database *predefinedDB, Database *customDB, std::unique_ptr<settings::Settings> settings)
            : QuotesAgent(predefinedDB, customDB, std::move(settings)){};
        ~QuotesAgentTester() = default;

        auto getCategoriesList() -> std::vector<CategoryRecord>
        {
            unsigned int offset = 0;
            unsigned int limit  = 0;

            auto request     = std::make_shared<Messages::GetCategoryListRequest>(offset, limit);
            auto queryResult = handleCategoryList(request);
            auto response    = dynamic_cast<Messages::GetCategoryListResponse *>(queryResult.get());
            return response->getResults();
        }

        auto getQuotesFromCustomCategory() -> std::vector<QuoteRecord>
        {
            unsigned int offset = 0;
            unsigned int limit  = 0;

            auto request     = std::make_shared<Messages::GetQuotesListFromCustomCategoryRequest>(offset, limit);
            auto queryResult = handleQuotesListFromCustomCategory(request);
            auto response    = dynamic_cast<Messages::GetQuotesListFromCustomCategoryResponse *>(queryResult.get());
            return response->getResults();
        }

        auto enableCategory(unsigned int categoryId, bool enable) -> bool
        {
            auto request     = std::make_shared<Messages::EnableCategoryByIdRequest>(categoryId, enable);
            auto queryResult = handleEnableCategoryById(request);
            auto response    = dynamic_cast<Messages::EnableCategoryByIdResponse *>(queryResult.get());
            return response->success;
        }

        auto enableQuote(unsigned int quoteId, bool enable) -> bool
        {
            auto request     = std::make_shared<Messages::EnableQuoteByIdRequest>(quoteId, enable);
            auto queryResult = handleEnableQuoteById(request);
            auto response    = dynamic_cast<Messages::EnableQuoteByIdResponse *>(queryResult.get());
            return response->success;
        }

        auto addQuote(std::string quote, std::string author, bool enabled) -> unsigned int
        {
            auto request = std::make_shared<Messages::AddQuoteRequest>(std::move(quote), std::move(author), enabled);
            auto queryResult = handleAddQuote(request);
            auto response    = dynamic_cast<Messages::AddQuoteResponse *>(queryResult.get());
            return response->quoteId;
        }

        auto readRandomizedQuote() -> std::unique_ptr<db::QueryResult>
        {
            auto request = std::make_shared<Messages::ReadRandomizedQuoteRequest>();
            return handleReadRandomizedQuote(request);
        }

        auto informLanguageChange() -> void
        {
            handleInformLanguageChange();
        }

        auto writeQuote(unsigned int quoteId, std::string quote, std::string author, bool enabled) -> bool
        {
            auto request =
                std::make_shared<Messages::WriteQuoteRequest>(quoteId, std::move(quote), std::move(author), enabled);
            auto queryResult = handleWriteQuote(request);
            auto response    = dynamic_cast<Messages::WriteQuoteResponse *>(queryResult.get());
            return response->success;
        }

        auto deleteQuote(unsigned int quoteId) -> bool
        {
            auto request     = std::make_shared<Messages::DeleteQuoteRequest>(quoteId);
            auto queryResult = handleDeleteQuote(request);
            auto response    = dynamic_cast<Messages::DeleteQuoteResponse *>(queryResult.get());
            return response->success;
        }
    };

    class SettingsMock : public settings::Settings
    {
      public:
        SettingsMock(std::string &quotesStr, std::string &timestampStr)
            : quotesString(quotesStr), timestampString(timestampStr)
        {}
        void setValue(const std::string &variableName,
                      const std::string &variableValue,
                      settings::SettingsScope scope = settings::SettingsScope::AppLocal)
        {
            if (variableName == settings::Quotes::randomQuotesList) {
                quotesString = variableValue;
            }
            else if (variableName == settings::Quotes::randomQuoteIDUpdateTime) {
                timestampString = variableValue;
            }
        }
        std::string getValue(const std::string &variableName,
                             settings::SettingsScope scope = settings::SettingsScope::AppLocal)
        {
            if (variableName == settings::Quotes::randomQuotesList) {
                return quotesString;
            }
            else if (variableName == settings::Quotes::randomQuoteIDUpdateTime) {
                return timestampString;
            }
            else {
                return std::string();
            }
        }
        std::string &quotesString;
        std::string &timestampString;
    };

} // namespace Quotes