diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..d66849f --- /dev/null +++ b/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) diff --git a/cmake/ksi_deps.cmake b/cmake/ksi_deps.cmake new file mode 100644 index 0000000..39a34e0 --- /dev/null +++ b/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) diff --git a/cmake/ksi_env.cmake b/cmake/ksi_env.cmake new file mode 100644 index 0000000..e6dd9fb --- /dev/null +++ b/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}") diff --git a/lib/SOSTestUtils/MockNamedFunction.hpp b/lib/SOSTestUtils/MockNamedFunction.hpp new file mode 100644 index 0000000..e69de29 diff --git a/lib/SOSTestUtils/sos_testing.hpp b/lib/SOSTestUtils/sos_testing.hpp new file mode 100644 index 0000000..6c3a09f --- /dev/null +++ b/lib/SOSTestUtils/sos_testing.hpp @@ -0,0 +1,110 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include + +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)); }); +} diff --git a/lib/tdxdbmock/CMakeLists.txt b/lib/tdxdbmock/CMakeLists.txt new file mode 100644 index 0000000..f66e08e --- /dev/null +++ b/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 + $ + $ +) + +set_target_properties(tdxdbmock PROPERTIES OUTPUT_NAME "tdxpgs") + +# add_library(tdxppdbmock_main +# SHARED +# ) diff --git a/lib/tdxdbmock/include/tdxdbmock/MockIField.hpp b/lib/tdxdbmock/include/tdxdbmock/MockIField.hpp new file mode 100644 index 0000000..a038393 --- /dev/null +++ b/lib/tdxdbmock/include/tdxdbmock/MockIField.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +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(); + } +}; diff --git a/lib/tdxdbmock/include/tdxdbmock/MockIParam.hpp b/lib/tdxdbmock/include/tdxdbmock/MockIParam.hpp new file mode 100644 index 0000000..94a4a0a --- /dev/null +++ b/lib/tdxdbmock/include/tdxdbmock/MockIParam.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include + +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(); + } +}; diff --git a/lib/tdxdbmock/include/tdxdbmock/MockIQuery.hpp b/lib/tdxdbmock/include/tdxdbmock/MockIQuery.hpp new file mode 100644 index 0000000..7e366e2 --- /dev/null +++ b/lib/tdxdbmock/include/tdxdbmock/MockIQuery.hpp @@ -0,0 +1,69 @@ +#pragma once + +#include +#include + +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)); +}; diff --git a/lib/tdxdbmock/include/tdxdbmock/MockTDXDB.hpp b/lib/tdxdbmock/include/tdxdbmock/MockTDXDB.hpp new file mode 100644 index 0000000..be51cdc --- /dev/null +++ b/lib/tdxdbmock/include/tdxdbmock/MockTDXDB.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include +#include + +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(); diff --git a/lib/tdxdbmock/include/tdxdbmock/MockTServiceImpl.hpp b/lib/tdxdbmock/include/tdxdbmock/MockTServiceImpl.hpp new file mode 100644 index 0000000..32d0e56 --- /dev/null +++ b/lib/tdxdbmock/include/tdxdbmock/MockTServiceImpl.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include + +#include + +#include +#include +#include +#include + +#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(); \ + }\ diff --git a/lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacade.hpp b/lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacade.hpp new file mode 100644 index 0000000..0241214 --- /dev/null +++ b/lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacade.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include + +#include + +#include +#include +#include +#include + +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; +}; diff --git a/lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacadeIQuery.hpp b/lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacadeIQuery.hpp new file mode 100644 index 0000000..62e617c --- /dev/null +++ b/lib/tdxdbmock/include/tdxdbmock/TDXDBMockFacadeIQuery.hpp @@ -0,0 +1,84 @@ +#pragma once + +#include + +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; +}; diff --git a/lib/tdxdbmock/src/MockIField.cpp b/lib/tdxdbmock/src/MockIField.cpp new file mode 100644 index 0000000..22fa623 --- /dev/null +++ b/lib/tdxdbmock/src/MockIField.cpp @@ -0,0 +1,5 @@ +#include + +MockIField::MockIField()=default; +MockIField::~MockIField()=default; + diff --git a/lib/tdxdbmock/src/MockIParam.cpp b/lib/tdxdbmock/src/MockIParam.cpp new file mode 100644 index 0000000..7ff7b41 --- /dev/null +++ b/lib/tdxdbmock/src/MockIParam.cpp @@ -0,0 +1,13 @@ +#include + +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; diff --git a/lib/tdxdbmock/src/MockIQuery.cpp b/lib/tdxdbmock/src/MockIQuery.cpp new file mode 100644 index 0000000..7ff79b4 --- /dev/null +++ b/lib/tdxdbmock/src/MockIQuery.cpp @@ -0,0 +1,4 @@ +#include + +MockIQuery::MockIQuery() = default; +MockIQuery::~MockIQuery() = default; diff --git a/lib/tdxdbmock/src/MockTDXDB.cpp b/lib/tdxdbmock/src/MockTDXDB.cpp new file mode 100644 index 0000000..62393c6 --- /dev/null +++ b/lib/tdxdbmock/src/MockTDXDB.cpp @@ -0,0 +1,6 @@ +#include + +MockTdxPgs & MockTdxPgsInstance(){ + static MockTdxPgs g_tdxPgsMock; + return g_tdxPgsMock; +} diff --git a/lib/tdxdbmock/src/MockTServiceImpl.cpp b/lib/tdxdbmock/src/MockTServiceImpl.cpp new file mode 100644 index 0000000..b0953d2 --- /dev/null +++ b/lib/tdxdbmock/src/MockTServiceImpl.cpp @@ -0,0 +1,108 @@ +// #include + +#include + +#include + +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