init

CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.19)
+
+project(ksi_testing LANGUAGES C CXX)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+include(FetchContent)
+FetchContent_Declare(googletest
+        URL     https://github.com/google/googletest/archive/refs/tags/v1.14.0.zip
+        URL_MD5 b4911e882c51cba34bebfb5df500a650
+)
+
+FetchContent_MakeAvailable(googletest)
+
+include(cmake/ksi_env.cmake)
+include(cmake/ksi_deps.cmake)
+
+add_subdirectory(lib/tdxdbmock)

cmake/ksi_deps.cmake

@@ -0,0 +1,37 @@
+function(ksi_find_library)
+    cmake_parse_arguments(
+        ARG
+        ""
+        "NAME;ALIAS;LIB"
+        "HINTS"
+        ${ARGN}
+    )
+    
+    set(_ksi_lib_paths
+        "${INTEGR_DIR}/lib"
+    )
+    
+    find_library(KSI_${ARG_LIB}_LIBARY ${ARG_LIB}
+        NO_DEFAULT_PATH
+        PATHS ${_ksi_lib_paths}
+    )
+
+    add_library(${ARG_NAME} INTERFACE IMPORTED)
+    add_library(${ARG_ALIAS} ALIAS ${ARG_NAME})
+    
+    target_include_directories(${ARG_NAME} SYSTEM INTERFACE ${INTEGR_DIR}/include)
+    target_link_libraries(${ARG_NAME} INTERFACE -l${ARG_LIB})
+    target_link_directories(${ARG_NAME} INTERFACE ${INTEGR_DIR}/lib)
+    
+    message("Found ${ARG_ALIAS} at ${KSI_${ARG_LIB}_LIBARY}")
+    
+endfunction()
+
+
+# LIB -> library that needs to be linked -lLIB
+# NAME -> name used by cmake
+
+ksi_find_library(LIB "tdxpp" NAME "TDXPP" ALIAS "TH::TDXPP")
+ksi_find_library(LIB "BFS_SOS" NAME "BFS_SOS" ALIAS "BFS::SOS")
+
+find_package(Boost REQUIRED)

cmake/ksi_env.cmake

@@ -0,0 +1,38 @@
+###TODO check for different directories
+if(DEFINED ENV{TUXDIR})
+  set(TUXDIR $ENV{TUXDIR})
+else()
+  set(TUXDIR /appksi/tuxedo/tuxedo12.2.2.0.0)
+endif()
+
+###TODO check for different directories
+if(DEFINED ENV{DISTDIR})
+  set(DISTDIR $ENV{DISTDIR})
+else()
+  set(DISTDIR /tmp) #this is sak only
+endif()
+
+if(DEFINED ENV{APPDIR})
+  set(INSTALL_TUX_DIR $ENV{APPDIR}/..)
+  set(INSTALL_BATCH_DIR $ENV{APPDIR}/../batch/WSP)
+else()
+  set(INSTALL_TUX_DIR ${CMAKE_CURRENT_BINARY_DIR}/instal_tux)
+  set(INSTALL_BATCH_DIR ${CMAKE_CURRENT_BINARY_DIR}/instal_batch)
+endif()
+
+
+set(INTEGR_DIR $ENV{INTEGRDIR})
+
+set(CMAKE_INSTALL_LIBDIR lib)
+
+list(APPEND CMAKE_PREFIX_PATH "/usr/pg-14")
+list(APPEND CMAKE_PREFIX_PATH "${INTEGR_DIR}/lib/cmake")
+list(APPEND CMAKE_PREFIX_PATH "/usr/include/boost169/")
+
+set(FAKE_GCC ${CMAKE_CURRENT_LIST_DIR}/gcc_mock.py)
+
+message("INTEGRDIR:         ${INTEGR_DIR}")
+message("TUXDIR:            ${TUXDIR}")
+message("DISTDIR:           ${DISTDIR}")
+message("INSTALL_TUX_DIR:   ${INSTALL_TUX_DIR}")
+message("INSTALL_BATCH_DIR: ${INSTALL_BATCH_DIR}")

lib/SOSTestUtils/sos_testing.hpp

@@ -0,0 +1,110 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <ESOS_Exception.h>
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <memory>
+
+namespace testing::internal {
+template < typename F >
+class MockFunctionNamed;
+
+template < typename R, typename... Args >
+class MockFunctionNamed< R(Args...) > {
+  public:
+    MockFunctionNamed(const MockFunctionNamed &)             = delete;
+    MockFunctionNamed & operator=(const MockFunctionNamed &) = delete;
+
+    std::function< R(Args...) > AsStdFunction() {
+        return [this](Args... args) -> R { return this->Call(std::forward< Args >(args)...); };
+    }
+    // Implementation detail: the expansion of the MOCK_METHOD macro.
+    R Call(Args... args) {
+        mock_.SetOwnerAndName(this, _name.c_str());
+        return mock_.Invoke(std::forward< Args >(args)...);
+    }
+
+    MockSpec< R(Args...) > gmock_Call(Matcher< Args >... m) {
+        mock_.RegisterOwner(this);
+        return mock_.With(std::move(m)...);
+    }
+
+    MockSpec< R(Args...) > gmock_Call(const WithoutMatchers &, R (*)(Args...)) {
+        return this->gmock_Call(::testing::A< Args >()...);
+    }
+
+  protected:
+    MockFunctionNamed(std::string name) : _name{"Call{" + name + "}"} {}
+    ~MockFunctionNamed() = default;
+
+  private:
+    std::string _name;
+    FunctionMocker< R(Args...) > mock_;
+};
+} // namespace testing::internal
+namespace testing {
+template < typename F >
+class MockFunctionNamed : public internal::MockFunctionNamed< internal::SignatureOfT< F > > {
+    using Base = internal::MockFunctionNamed< internal::SignatureOfT< F > >;
+
+  public:
+    MockFunctionNamed(std::string name) : Base{std::move(name)} {}
+};
+} // namespace testing
+
+template < class Function >
+std::function< void() > single_call(Function function) {
+    auto shared_exception_ptr = std::make_shared< std::exception_ptr >();
+    auto was_called           = std::make_shared< bool >(false);
+    return [shared_exception_ptr, was_called, function]() {
+        if(*shared_exception_ptr) {
+            std::rethrow_exception(*shared_exception_ptr);
+        }
+        if(*was_called) {
+            return;
+        }
+        *was_called = true;
+        try {
+            std::invoke(function);
+        } catch(...) {
+            *shared_exception_ptr = std::current_exception();
+            std::rethrow_exception(*shared_exception_ptr);
+        }
+    };
+}
+
+class ESOS_Error_testable {
+    std::string description, usermsg;
+
+  public:
+    ESOS_Error_testable(ESOS_Exception & e) : description{e.GetDesc().c_str()}, usermsg{e.GetUserMsg().c_str()} {}
+
+    const std::string & GetDesc() const {
+        return description;
+    }
+
+    const std::string & GetUserMsg() const {
+        return usermsg;
+    }
+};
+
+template < typename Fun >
+auto rethrow_esos_as_testable_esos_exception(Fun && f) {
+    try {
+        return f();
+    } catch(ESOS_Exception & esos_error) {
+        throw ESOS_Error_testable{esos_error};
+    } catch(...) {
+        throw std::runtime_error{""};
+    }
+}
+
+template < typename Callable >
+auto single_rethrow_esos_exception(Callable && C) {
+    return single_call([&]() { rethrow_esos_as_testable_esos_exception(std::forward< Callable >(C)); });
+}

lib/tdxdbmock/CMakeLists.txt

@@ -0,0 +1,33 @@
+add_library(tdxdbmock
+    SHARED
+        ./src/MockIField.cpp
+        ./src/MockTDXDB.cpp
+        ./src/MockIParam.cpp
+        ./src/MockIQuery.cpp
+        ./src/MockTServiceImpl.cpp
+    
+        ./include/tdxdbmock/TDXDBMockFacade.hpp
+        ./include/tdxdbmock/MockTServiceImpl.hpp
+        ./include/tdxdbmock/MockTDXDB.hpp
+        ./include/tdxdbmock/MockIParam.hpp
+        ./include/tdxdbmock/MockIQuery.hpp
+        ./include/tdxdbmock/MockIField.hpp
+)
+
+target_link_libraries(tdxdbmock
+    PUBLIC
+        TH::TDXPP
+        gmock
+)
+
+target_include_directories(tdxdbmock
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+set_target_properties(tdxdbmock PROPERTIES OUTPUT_NAME "tdxpgs")
+
+# add_library(tdxppdbmock_main
+#     SHARED
+# )

lib/tdxdbmock/include/tdxdbmock/MockIField.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <uniqry.h>
+
+class MockIField : public TDXPP::IField {
+  public:
+    MockIField();
+    ~MockIField();
+    
+    MOCK_METHOD(TString, GetName, (), (const, override));
+    MOCK_METHOD(TAny, GetValue, (), (const, override));
+    MOCK_METHOD(TAnyValueType, GetType, (), (const, override));
+    
+    TString GetAsString() const override {
+        return GetValue().GetAsString();
+    }
+    int GetAsInteger() const override {
+        return static_cast< int >(GetValue());
+    }
+    double GetAsFloat() const override {
+        return static_cast< double >(GetValue());
+    }
+    TDateTime GetAsDateTime() const override {
+        return GetValue().GetAsDateTime();
+    }
+    TDate GetAsDate() const override {
+        return GetValue().GetAsDateTime().AsDate();
+    }
+    TTime GetAsTime() const override {
+        return GetValue().GetAsDateTime().AsTime();
+    }
+    bool GetAsBool() const override {
+        return static_cast< bool >(GetValue());
+    }
+    long long GetAsBigInt() const override {
+        return GetValue().GetAsBigInt();
+    }
+};

lib/tdxdbmock/include/tdxdbmock/MockIParam.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <uniqry.h>
+
+class MockIParam : public IParam {
+    std::string _name;
+    TAny _value;
+
+    // IParam interface
+  public:
+    MockIParam();
+    ~MockIParam();
+
+    MOCK_METHOD(TString, GetName, (), (const, override));
+    MOCK_METHOD(TAny, GetValue, (), (const, override));
+    MOCK_METHOD(void, SetValue, (const TAny & Value), (override));
+    MOCK_METHOD(void, SetValueAs, (const TAny & Value, TAnyValueType Type), (override));
+    MOCK_METHOD(TAnyValueType, GetType, (), (const, override));
+    MOCK_METHOD(void, SetType, (TAnyValueType Type), (override));
+
+    TString GetAsString() const override {
+        return GetValue().GetAsString();
+    }
+    int GetAsInteger() const override {
+        return static_cast< int >(GetValue());
+    }
+    double GetAsFloat() const override {
+        return static_cast< double >(GetValue());
+    }
+    TDateTime GetAsDateTime() const override {
+        return GetValue().GetAsDateTime();
+    }
+    TDate GetAsDate() const override {
+        return GetValue().GetAsDateTime().AsDate();
+    }
+    TTime GetAsTime() const override {
+        return GetValue().GetAsDateTime().AsTime();
+    }
+    bool GetAsBool() const override {
+        return static_cast< bool >(GetValue());
+    }
+    long long GetAsBigInt() const override {
+        return GetValue().GetAsBigInt();
+    }
+};

lib/tdxdbmock/include/tdxdbmock/MockIQuery.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <uniqry.h>
+
+class MockIQuery : public TDXPP::IQuery {
+  public:
+    MockIQuery();
+    ~MockIQuery();
+    int _ref{1};
+    virtual int AddRef() override {
+        ++_ref;
+        return _ref;
+    };
+    virtual int Release() override {
+        _ref--;
+        int ref = (_ref < 1) ? 0 : _ref;
+        if(_ref < 1)
+            DeleteThis();
+        return ref;
+    };
+    MOCK_METHOD(void, DeleteThis, (), ());
+
+    /// query string management
+    MOCK_METHOD(void, SetSQL, (TString SQL), (override));
+    MOCK_METHOD(TString, GetSQL, (), (const, override));
+    MOCK_METHOD(TString, GetRawSQL, (), (const, override));
+    MOCK_METHOD(TString, GetParamSQL, (), (const, override));
+    MOCK_METHOD(TStmType, GetStmType, (), (const, override));
+
+    // query control
+    MOCK_METHOD(bool, IsPrepared, (), (override));
+    MOCK_METHOD(bool, IsOpened, (), (override));
+    MOCK_METHOD(bool, IsEOF, (), (override));
+    MOCK_METHOD(void, Prepare, (), (override));
+    MOCK_METHOD(void, Execute, (), (override));
+    MOCK_METHOD(void, BatchExecute, (IRecordset * Rst), (override));
+    MOCK_METHOD(void, Open, (), (override));
+    MOCK_METHOD(void, Close, (), (override));
+    MOCK_METHOD(void, SetStrictMode, (bool Enabled), (override));
+    MOCK_METHOD(bool, GetStrictMode, (), (const, override));
+    MOCK_METHOD(int, GetQueryNo, (), (const, override));
+    MOCK_METHOD(int, GetLastSerial, (), (const, override));
+
+    // query parameters
+    MOCK_METHOD(int, FindParam, (TString Name), (const, override));
+    MOCK_METHOD(IParam *, GetParam, (TString Name), (override));
+    MOCK_METHOD(IParam *, GetParam, (int Num), (override));
+    MOCK_METHOD(void, SetParamByName, (TString Name, TAny Value), (override));
+    MOCK_METHOD(void, SetParamByNameEx, (TString Name, TAny Value, TAnyValueType Type), (override));
+    MOCK_METHOD(void, SetParams, (IRecordset * Rst), (override));
+    MOCK_METHOD(void, SetParams, (IRecordset * Rst, int Occ), (override));
+    MOCK_METHOD(void, SetParams, (IQuery * Query), (override));
+    MOCK_METHOD(int, GetParamCount, (), (const, override));
+
+    // query result
+    MOCK_METHOD(int, FindField, (TString Name), (const, override));
+    MOCK_METHOD(IField *, GetField, (TString Name), (override));
+    MOCK_METHOD(IField *, GetField, (int Num), (override));
+    MOCK_METHOD(int, GetFieldCount, (), (const, override));
+    MOCK_METHOD(bool, FetchRow, (), (override));
+    MOCK_METHOD(void, CopyRow, (IRecordset * Rst), (override));
+    MOCK_METHOD(void, FetchAll, (IRecordset * Rst), (override));
+    MOCK_METHOD(TDBEngine, GetDBEngine, (), (const, override));
+    MOCK_METHOD(int, GetRowsAffected, (), (const, override));
+    MOCK_METHOD(void, FetchFirst, (IRecordset * Rst, int & Limit), (override));
+    MOCK_METHOD(void, FetchFirst, (IRecordset * Rst, int & Limit, bool & AllFetched), (override));
+    MOCK_METHOD(TString, GetCursorName, (), (const, override));
+};

lib/tdxdbmock/include/tdxdbmock/MockTDXDB.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <uniqry.h>
+
+class MockTdxPgs {
+  public:
+    MOCK_METHOD(IQuery *, CreateQuery, (), ());
+    MOCK_METHOD(void, SQLImmediate, (TString SQL), ());
+    MOCK_METHOD(int, SQLCode, (), ());
+    MOCK_METHOD(void, SetCurrentSQLID, (TString SQLID), ());
+    MOCK_METHOD(TString, GetCurrentSQLID, (), ());
+    MOCK_METHOD(void, SetCurrentPackageSet, (TString PACKAGESET), ());
+    MOCK_METHOD(TString, GetCurrentPackageSet, (), ());
+    MOCK_METHOD(TDBEngine, GetDBEngine, (), ());
+    MOCK_METHOD(int, GetQueryCount, (), ());
+    MOCK_METHOD(int, GetQueryLimit, (), ());
+};
+
+MockTdxPgs & MockTdxPgsInstance();

lib/tdxdbmock/include/tdxdbmock/MockTServiceImpl.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <gmock/gmock.h>
+
+#include <uniqry.h>
+
+#include <tdxdbmock/MockIField.hpp>
+#include <tdxdbmock/MockIParam.hpp>
+#include <tdxdbmock/MockIQuery.hpp>
+#include <tdxdbmock/MockTDXDB.hpp>
+
+#define TDXDBMAIN()                                  \
+    int main(int argc, char ** argv) {               \
+        ReportMsgSetBackend([](auto) { return 0; }); \
+        TDXPP::SetVerboseMode(slError);              \
+        TDXPP::SetSingleSQLTime(0);                  \
+        TDXPP::SetProfilerTime(0);                   \
+        TDXPP::SetFastStrHeapActive(false);          \
+        testing::InitGoogleMock(&argc, argv);        \
+        return RUN_ALL_TESTS();                      \
+    }\

lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacade.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <gmock/gmock.h>
+
+#include <uniqry.h>
+
+#include <tdxdbmock/MockIField.hpp>
+#include <tdxdbmock/MockIParam.hpp>
+#include <tdxdbmock/MockIQuery.hpp>
+#include <tdxdbmock/MockTDXDB.hpp>
+
+template < typename Any_t >
+class DBMockFasade {
+  public:
+    virtual ~DBMockFasade() = default;
+
+    virtual IQuery * get_query_obj() = 0;
+
+    // tdxpp release usunie obiekt
+    virtual void expect_createDestroy() = 0;
+
+    // za³ó¿ ¿e obiekt query dostanie SQL'a, zostanie otwarty i zamkniêty w podanej kolejno¶ci
+    virtual void expect_setSqlOpenClose() = 0;
+
+    // za³ó¿ ¿e obiekt query dostanie SQL'a i zostanie wywo³ana funkcja execute (bez zwracania danych) oraz ¿e metoda rows affected zwróci
+    // podan± ilo¶æ 'dotkniêtych' rekordów
+    virtual void expect_setSqlExecute(std::optional< int > rowsAffected = {}) = 0;
+
+    virtual void expect_query_parameter_matches(std::string name, testing::Matcher< const TAny & > valueMatcher)              = 0;
+    virtual void expect_parameters_matches_any_n(int n)                                                                       = 0;
+    virtual void expect_parameters_matches(std::vector< std::pair< std::string, testing::Matcher< const Any_t & > > > params) = 0;
+
+    virtual void expect_result_empty()                                               = 0;
+    virtual void expect_result(std::vector< std::map< std::string, Any_t > > fields) = 0;
+};

lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacadeIQuery.hpp

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <tdxdbmock/TDXDBMockFacade.hpp>
+
+using namespace testing;
+class IQueryMock_FetchRow : public DBMockFasade< TAny > {
+    // DBMock interface
+    auto & mock() {
+        return _mock;
+    }
+    
+  public:
+    IQueryMock_FetchRow() {}
+    
+    
+    IQuery * get_query_obj() override {
+        return &mock();
+    }
+    
+    void expect_createDestroy() override {
+        EXPECT_CALL(mock(), DeleteThis()); // global will not have this call at all
+    }
+    
+    void expect_setSqlOpenClose() override {
+        setSql = EXPECT_CALL(mock(), SetSQL(_));
+        open   = EXPECT_CALL(mock(), Open()).After(setSql);
+        
+        EXPECT_CALL(mock(), Close()).Times(AtLeast(1)).After(open); // on throw, exception handler closes the query
+    }
+    
+    void expect_setSqlExecute(std::optional< int > rowsAffected = {}) override {
+        setSql              = EXPECT_CALL(mock(), SetSQL(_));
+        Expectation execute = EXPECT_CALL(mock(), Execute()).After(setSql);
+        if(rowsAffected)
+            EXPECT_CALL(mock(), GetRowsAffected()).After(execute).WillRepeatedly(Return(rowsAffected.value()));
+        
+        EXPECT_CALL(mock(), Close()).Times(AtMost(1)); // for exception handler
+    }
+    
+    void expect_parameters_matches_any_n(int n) override {
+        EXPECT_CALL(mock(), GetParam(Matcher< TString >(_))).Times(n).WillRepeatedly(Return(std::addressof(_params["generic"])));
+        EXPECT_CALL(_params["generic"], SetValueAs(_, _)).Times(n);
+        
+        // dla SetParamByNameEx zamiast GetParam()->SetValueAs
+        EXPECT_CALL(mock(), SetParamByNameEx(Matcher< TString >(_), _, _))
+          .Times(AtMost(n))
+          .WillRepeatedly(Invoke([this](auto n, auto v, auto t) { this->mock().GetParam(n)->SetValueAs(v, t); }));
+    }
+    
+    void expect_parameters_matches(std::vector< std::pair< std::string, testing::Matcher< const TAny & > > > params) override {
+        for(const auto & [name, valueMatcher] : params) {
+            expect_query_parameter_matches(name, valueMatcher);
+        }
+        
+        // dla SetParamByNameEx zamiast GetParam()->SetValueAs
+        EXPECT_CALL(mock(), SetParamByNameEx(Matcher< TString >(_), _, _))
+          .Times(AtMost(params.size()))
+          .WillRepeatedly(Invoke([this](auto n, auto v, auto t) { this->mock().GetParam(n)->SetValueAs(v, t); }));
+    }
+    
+    void expect_query_parameter_matches(std::string name, Matcher< const TAny & > valueMatcher) override {
+        EXPECT_CALL(mock(), GetParam(Matcher< TString >(name.c_str()))).WillOnce(Return(std::addressof(_params[name])));
+        EXPECT_CALL(_params[name], SetValueAs(valueMatcher, _));
+    }
+    
+    void expect_result(std::vector< std::map< std::string, TAny > > fields) override {
+        EXPECT_CALL(mock(), FetchRow()).Times(fields.size()).After(open).WillOnce(Return(true));
+        for(const auto & row : fields) {
+            for(const auto & [name, field] : row) {
+                EXPECT_CALL(mock(), GetField(Matcher< TString >(TString{name.c_str()}))).WillOnce(Return(std::addressof(_fields[name])));
+                EXPECT_CALL(_fields[name], GetValue()).WillOnce(Return(field));
+            }
+        }
+    }
+    
+    void expect_result_empty() override {
+        EXPECT_CALL(mock(), FetchRow()).After(open).WillOnce(Return(false));
+    }
+    
+    testing::StrictMock< MockIQuery > _mock;
+    testing::Expectation setSql, open;
+    std::map< std::string, MockIParam > _params;
+    std::map< std::string, MockIField > _fields;
+};

lib/tdxdbmock/src/MockIField.cpp

@@ -0,0 +1,5 @@
+#include <tdxdbmock/MockIField.hpp>
+
+MockIField::MockIField()=default;
+MockIField::~MockIField()=default;
+

lib/tdxdbmock/src/MockIParam.cpp

@@ -0,0 +1,13 @@
+#include <tdxdbmock/MockIParam.hpp>
+
+MockIParam::MockIParam() {
+    using namespace testing;
+    ON_CALL(*this, GetName()).WillByDefault(Return(TString{_name.c_str()}));
+    ON_CALL(*this, GetValue()).WillByDefault(Return(_value));
+    
+    ON_CALL(*this, SetValue(_)).WillByDefault(SaveArg< 0 >(&_value));
+    ON_CALL(*this, SetValueAs(_, _)).WillByDefault(Invoke([&](const auto & v, auto t) { _value = TAny{v, t}; }));
+    ON_CALL(*this, SetType(_)).WillByDefault(Invoke([&](auto t) { _value.ChangeType(t); }));
+}
+
+MockIParam::~MockIParam() = default;

lib/tdxdbmock/src/MockIQuery.cpp

@@ -0,0 +1,4 @@
+#include <tdxdbmock/MockIQuery.hpp>
+
+MockIQuery::MockIQuery() = default;
+MockIQuery::~MockIQuery() = default;

lib/tdxdbmock/src/MockTDXDB.cpp

@@ -0,0 +1,6 @@
+#include <tdxdbmock/MockTDXDB.hpp>
+
+MockTdxPgs & MockTdxPgsInstance(){
+    static MockTdxPgs g_tdxPgsMock;
+    return g_tdxPgsMock;
+}

lib/tdxdbmock/src/MockTServiceImpl.cpp

@@ -0,0 +1,108 @@
+// #include </home/bartoszek/builds/ksi/sp/include/uniqry.h>
+
+#include <tdxdbmock/MockTServiceImpl.hpp>
+
+#include <tuximp.h>
+
+IQuery * query;
+
+namespace TDXPP {
+
+IQuery * CreateQuery() {
+    return MockTdxPgsInstance().CreateQuery();
+}
+
+void SQLImmediate(TString SQL) {
+    MockTdxPgsInstance().SQLImmediate(SQL);
+}
+
+int SQLCode() {
+    return MockTdxPgsInstance().SQLCode();
+}
+
+void SetCurrentSQLID(TString SQLID) {
+    MockTdxPgsInstance().SetCurrentSQLID(SQLID);
+}
+
+TString GetCurrentSQLID() {
+    return MockTdxPgsInstance().GetCurrentSQLID();
+}
+
+void SetCurrentPackageSet(TString PACKAGESET) {
+    MockTdxPgsInstance().SetCurrentPackageSet(PACKAGESET);
+}
+
+TString GetCurrentPackageSet() {
+    return MockTdxPgsInstance().GetCurrentPackageSet();
+}
+
+TDBEngine GetDBEngine() {
+    return MockTdxPgsInstance().GetDBEngine();
+}
+
+int GetQueryCount() {
+    return MockTdxPgsInstance().GetQueryCount();
+}
+
+int GetQueryLimit() {
+    return MockTdxPgsInstance().GetQueryLimit();
+}
+
+TSQLServiceImpl::TSQLServiceImpl() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+TSQLServiceImpl::~TSQLServiceImpl() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+void TSQLServiceImpl::Init() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+void TSQLServiceImpl::Run(TPSVCINFO * rqst) {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+TString TSQLServiceImpl::GetSQL() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+    return "";
+};
+
+IQuery * TSQLServiceImpl::GetQuery() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+    assert(false);
+    return nullptr;
+}
+
+void TSQLServiceImpl::ApplySQL() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+IRecordset * TQDSSvcImpl::GetQDSRst(TRstDir Dir) {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+    assert(false);
+    return nullptr;
+}
+
+void TQDSSelectSvcImpl::Implementation() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+void TQDSRefreshSvcImpl::Implementation() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+void TQDSInsertSvcImpl::Implementation() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+void TQDSUpdateSvcImpl::Implementation() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+void TQDSDeleteSvcImpl::Implementation() {
+    std::clog << __PRETTY_FUNCTION__ << ":" << __LINE__ << "\n";
+}
+
+} // namespace TDXPP