From 2c50e3ee7f765d00bd5f3455ab65cc9ef564eb2f Mon Sep 17 00:00:00 2001 From: Bartosz Wieczorek Date: Thu, 25 Jan 2018 14:28:45 +0100 Subject: [PATCH] refactor --- src/app/main.cpp | 2 +- src/eedb/CMakeLists.txt | 2 +- src/eedb/EEDB.cpp | 8 +- src/eedb/Session.hpp | 22 +- src/eedb/{Session.cpp => WebSession.cpp} | 6 +- src/eedb/WebSession.hpp | 35 ++ src/eedb/widgets/AuthPage.hpp | 2 +- src/eedb/widgets/DefaultAuthPage.cpp | 13 +- src/eedb/widgets/DefaultAuthPage.hpp | 18 +- src/utils/spimpl.hpp | 446 +++++++++++++++++++++++ tests/CMakeLists.txt | 2 +- tests/mocks/CMakeLists.txt | 10 - tests/mocks/SessionMock.hpp | 5 + tests/mocks/db/UserDatabaseMock.hpp | 11 + tests/mocks/dummy.cpp | 2 - tests/mocks/widgets/AuthPageMock.hpp | 2 +- tests/unit/CMakeLists.txt | 7 +- tests/unit/WidgetTest.hpp | 4 +- tests/unit/test_eedb_DefaultAuthPage.cpp | 22 +- tests/unit/test_eedb_DefaultHomePage.cpp | 2 + tests/unit/test_eedb_application.cpp | 22 +- 21 files changed, 557 insertions(+), 86 deletions(-) rename src/eedb/{Session.cpp => WebSession.cpp} (77%) create mode 100644 src/eedb/WebSession.hpp create mode 100644 src/utils/spimpl.hpp delete mode 100644 tests/mocks/CMakeLists.txt create mode 100644 tests/mocks/db/UserDatabaseMock.hpp delete mode 100644 tests/mocks/dummy.cpp diff --git a/src/app/main.cpp b/src/app/main.cpp index 45b851c..ef25f7e 100644 --- a/src/app/main.cpp +++ b/src/app/main.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include diff --git a/src/eedb/CMakeLists.txt b/src/eedb/CMakeLists.txt index 070f70b..030f982 100644 --- a/src/eedb/CMakeLists.txt +++ b/src/eedb/CMakeLists.txt @@ -1,6 +1,6 @@ file(GLOB SOURCE EEDB.cpp - Session.cpp + WebSession.cpp auth/PgUserAuth.cpp auth/Services.cpp diff --git a/src/eedb/EEDB.cpp b/src/eedb/EEDB.cpp index c4bd14c..330f4f4 100644 --- a/src/eedb/EEDB.cpp +++ b/src/eedb/EEDB.cpp @@ -39,17 +39,15 @@ EEDB::EEDB(std::unique_ptr< Session > session, AuthPageFactory authPageFactory, setTheme(_theme->create()); _authPage = _authPageFactory(); - _authPage->registerNeedVerification([] {}); - _authPage->registerOnUserWeakLogin([=] { authEventLogin(LoginState::weak); }); - _authPage->registerOnUserStrongLogin([=] { authEventLogin(LoginState::strong); }); + _authPage->registerOnNeedVerification([] {}); + _authPage->registerOnUserWeakLogin([&] { authEventLogin(LoginState::weak); }); + _authPage->registerOnUserStrongLogin([&] { authEventLogin(LoginState::strong); }); _authPage->registerOnUserLogout([=] { authEventLogout(); }); _authPage->attachTo(root()); _authPage->processEnvironment(); } void EEDB::authEventLogin(EEDB::LoginState state) { -// using namespace Wt; - root()->removeStyleClass("container"); _authPage->detach(); _homePage = _homePageFactory(); diff --git a/src/eedb/Session.hpp b/src/eedb/Session.hpp index df04676..f87fffd 100644 --- a/src/eedb/Session.hpp +++ b/src/eedb/Session.hpp @@ -1,8 +1,5 @@ #pragma once -#include -#include - namespace eedb::auth { class PgUserAuth; } @@ -11,9 +8,15 @@ namespace eedb::db { class PgConnection; }; +namespace Wt{ +class WEnvironment; +} + namespace Wt::Auth { class AbstractUserDatabase; +class Login; } + namespace eedb { class Session { @@ -25,17 +28,4 @@ class Session { virtual Wt::Auth::Login & login() = 0; }; -class WebSession final : public Session { - public: - WebSession(std::unique_ptr< eedb::db::PgConnection > dbConnection, const Wt::WEnvironment & env); - - eedb::db::PgConnection & db() override; - const Wt::WEnvironment & enviroment() const override; - Wt::Auth::Login & login() override; - - private: - std::unique_ptr< eedb::db::PgConnection > _dbConnection; - Wt::Auth::Login _login; - const Wt::WEnvironment & _env; -}; } // namespace eedb diff --git a/src/eedb/Session.cpp b/src/eedb/WebSession.cpp similarity index 77% rename from src/eedb/Session.cpp rename to src/eedb/WebSession.cpp index 974bbdb..b54dd0e 100644 --- a/src/eedb/Session.cpp +++ b/src/eedb/WebSession.cpp @@ -1,11 +1,13 @@ -#include +#include #include #include namespace eedb { WebSession::WebSession(std::unique_ptr< eedb::db::PgConnection > dbConnection, const Wt::WEnvironment & env) - : _dbConnection(std::move(dbConnection)), _env(env) {} + : _dbConnection(std::move(dbConnection)), _env(env) {} + +WebSession::~WebSession() =default; db::PgConnection & WebSession::db() { return *_dbConnection; diff --git a/src/eedb/WebSession.hpp b/src/eedb/WebSession.hpp new file mode 100644 index 0000000..c6921a5 --- /dev/null +++ b/src/eedb/WebSession.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include + +#include + +namespace eedb::auth { +class PgUserAuth; +} + +namespace eedb::db { +class PgConnection; +}; + +namespace Wt::Auth { +class AbstractUserDatabase; +} +namespace eedb { + +class WebSession final : public Session { + public: + explicit WebSession(std::unique_ptr< eedb::db::PgConnection > dbConnection, const Wt::WEnvironment & env); + ~WebSession() override; + + eedb::db::PgConnection & db() override; + const Wt::WEnvironment & enviroment() const override; + Wt::Auth::Login & login() override; + + private: + std::unique_ptr< eedb::db::PgConnection > _dbConnection; + Wt::Auth::Login _login; + const Wt::WEnvironment & _env; +}; +} // namespace eedb diff --git a/src/eedb/widgets/AuthPage.hpp b/src/eedb/widgets/AuthPage.hpp index 4879f3b..def03e2 100644 --- a/src/eedb/widgets/AuthPage.hpp +++ b/src/eedb/widgets/AuthPage.hpp @@ -16,7 +16,7 @@ class AuthPage { virtual void detach() = 0; virtual void processEnvironment() = 0; - virtual void registerNeedVerification(std::function< void() > f) = 0; + virtual void registerOnNeedVerification(std::function< void() > f) = 0; virtual void registerOnUserWeakLogin(std::function< void() > f) = 0; virtual void registerOnUserStrongLogin(std::function< void() > f) = 0; virtual void registerOnUserLogout(std::function< void() > f) = 0; diff --git a/src/eedb/widgets/DefaultAuthPage.cpp b/src/eedb/widgets/DefaultAuthPage.cpp index 62fb760..a53470a 100644 --- a/src/eedb/widgets/DefaultAuthPage.cpp +++ b/src/eedb/widgets/DefaultAuthPage.cpp @@ -43,7 +43,7 @@ struct DefaultAuthPage::DefaultAuthPagePriv { DefaultAuthPage::DefaultAuthPage(const auth::Services & baseAuth, std::unique_ptr< Wt::Auth::AbstractUserDatabase > userDatabase, Wt::Auth::Login & _login) - : _priv(std::make_unique< DefaultAuthPagePriv >(baseAuth, std::move(userDatabase), _login)) { + : _priv(spimpl::make_unique_impl< DefaultAuthPagePriv >(baseAuth, std::move(userDatabase), _login)) { _priv->_authWidget->login().changed().connect([this]() { if(_priv->_authWidget->login().state() == Wt::Auth::LoginState::Strong) { this->notifyUserStrongLogin(); @@ -57,15 +57,6 @@ DefaultAuthPage::DefaultAuthPage(const auth::Services & baseAuth, }); } -DefaultAuthPage::DefaultAuthPage(DefaultAuthPage && rhs) : _priv(std::move(rhs._priv)) {} - -DefaultAuthPage::~DefaultAuthPage() = default; - -DefaultAuthPage & DefaultAuthPage::operator=(DefaultAuthPage && rhs) { - _priv = std::move(rhs._priv); - return *this; -} - void DefaultAuthPage::attachTo(Wt::WContainerWidget * parent) { parent->addWidget(std::move(_priv->_authWidget)); } @@ -81,7 +72,7 @@ void DefaultAuthPage::processEnvironment() { _priv->_authWidget->processEnvironment(); } -void DefaultAuthPage::registerNeedVerification(std::function< void() > f) { +void DefaultAuthPage::registerOnNeedVerification(std::function< void() > f) { _priv->_onNeedEmailVerification.connect([=]() { f(); }); } diff --git a/src/eedb/widgets/DefaultAuthPage.hpp b/src/eedb/widgets/DefaultAuthPage.hpp index 31c378f..1398a2a 100644 --- a/src/eedb/widgets/DefaultAuthPage.hpp +++ b/src/eedb/widgets/DefaultAuthPage.hpp @@ -2,7 +2,7 @@ #include -#include +#include namespace Wt::Auth { class AbstractUserDatabase; @@ -16,24 +16,16 @@ class Services; namespace eedb { class DefaultAuthPage final : public AuthPage { public: - DefaultAuthPage(const eedb::auth::Services & baseAuth, + DefaultAuthPage( // + const auth::Services & baseAuth, std::unique_ptr< Wt::Auth::AbstractUserDatabase > userDatabase, Wt::Auth::Login & session); - DefaultAuthPage(const DefaultAuthPage &) = delete; - DefaultAuthPage(DefaultAuthPage &&); - - ~DefaultAuthPage() override; - - // clang-format off - DefaultAuthPage & operator=(const DefaultAuthPage &) = delete; - DefaultAuthPage & operator=(DefaultAuthPage &&); - // clang-format on void attachTo(Wt::WContainerWidget * parent) override; void detach() override; void processEnvironment() override; - void registerNeedVerification(std::function< void() > f) override; + void registerOnNeedVerification(std::function< void() > f) override; void registerOnUserWeakLogin(std::function< void() > f) override; void registerOnUserStrongLogin(std::function< void() > f) override; void registerOnUserLogout(std::function< void() > f) override; @@ -46,6 +38,6 @@ class DefaultAuthPage final : public AuthPage { private: struct DefaultAuthPagePriv; - std::unique_ptr< DefaultAuthPagePriv > _priv; + spimpl::unique_impl_ptr< DefaultAuthPagePriv > _priv; }; } // namespace eedb diff --git a/src/utils/spimpl.hpp b/src/utils/spimpl.hpp new file mode 100644 index 0000000..a20c11d --- /dev/null +++ b/src/utils/spimpl.hpp @@ -0,0 +1,446 @@ +/* + ==================================================================== + A Smart Pointer to IMPLementation (i.e. Smart PIMPL or just SPIMPL). + ==================================================================== + + Version: 1.1 + + Latest version: + https://github.com/oliora/samples/blob/master/spimpl.h + Rationale and description: + http://oliora.github.io/2015/12/29/pimpl-and-rule-of-zero.html + + Copyright (c) 2015 Andrey Upadyshev (oliora@gmail.com) + + Distributed under the Boost Software License, Version 1.0. + See http://www.boost.org/LICENSE_1_0.txt + + Changes history + --------------- + v1.1: + - auto_ptr support is disabled by default for C++17 compatibility + v1.0: + - Released + */ + +#ifndef SPIMPL_H_ +#define SPIMPL_H_ + +#include +#include +#include + + +#if defined _MSC_VER && _MSC_VER < 1900 // MS Visual Studio before VS2015 +#define SPIMPL_NO_CPP11_NOEXCEPT +#define SPIMPL_NO_CPP11_CONSTEXPR +#define SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC +#endif + +#if ! defined SPIMPL_NO_CPP11_NOEXCEPT +#define SPIMPL_NOEXCEPT noexcept +#else +#define SPIMPL_NOEXCEPT +#endif + +#if ! defined SPIMPL_NO_CPP11_CONSTEXPR +#define SPIMPL_CONSTEXPR constexpr +#else +#define SPIMPL_CONSTEXPR +#endif + +// define SPIMPL_HAS_AUTO_PTR to enable constructor and assignment operator that accept std::auto_ptr +// TODO: auto detect std::auto_ptr support + + +namespace spimpl { + namespace details { + template + T *default_copy(T *src) + { + static_assert(sizeof(T) > 0, "default_copy cannot copy incomplete type"); + static_assert(!std::is_void::value, "default_copy cannot copy incomplete type"); + return new T(*src); + } + + template + void default_delete(T *p) SPIMPL_NOEXCEPT + { + static_assert(sizeof(T) > 0, "default_delete cannot delete incomplete type"); + static_assert(!std::is_void::value, "default_delete cannot delete incomplete type"); + delete p; + } + + template + struct default_deleter { + using type = void (*)(T*); + }; + + template + using default_deleter_t = typename default_deleter::type; + + template + struct default_copier { + using type = T* (*)(T*); + }; + + template + using default_copier_t = typename default_copier::type; + + template + struct is_default_manageable: public std::integral_constant>::value && + std::is_same>::value + > {}; + } + + + template, class Copier = details::default_copier_t> + class impl_ptr + { + private: + static_assert(!std::is_array::value, "impl_ptr specialization for arrays is not implemented"); + struct dummy_t_ {int dummy__;}; + + public: + using pointer = T*; + using element_type = T; + using copier_type = typename std::decay::type; + using deleter_type = typename std::decay::type; + using unique_ptr_type = std::unique_ptr; + using is_default_manageable = details::is_default_manageable; + + SPIMPL_CONSTEXPR impl_ptr() SPIMPL_NOEXCEPT + : ptr_(nullptr, deleter_type{}), copier_(copier_type{}) {} + + SPIMPL_CONSTEXPR impl_ptr(std::nullptr_t) SPIMPL_NOEXCEPT + : impl_ptr() {} + + template + impl_ptr(pointer p, D&& d, C&& c, + typename std::enable_if< + std::is_convertible::value + && std::is_convertible::value, + dummy_t_ + >::type = dummy_t_()) SPIMPL_NOEXCEPT + : ptr_(std::move(p), std::forward(d)), copier_(std::forward(c)) {} + + template + impl_ptr(U *u, + typename std::enable_if< + std::is_convertible::value + && is_default_manageable::value, + dummy_t_ + >::type = dummy_t_()) SPIMPL_NOEXCEPT + : impl_ptr(u, &details::default_delete, &details::default_copy) {} + + impl_ptr(const impl_ptr& r) + : impl_ptr(r.clone()) {} + +#ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC + impl_ptr(impl_ptr&& r) SPIMPL_NOEXCEPT = default; +#else + impl_ptr(impl_ptr&& r) SPIMPL_NOEXCEPT + : ptr_(std::move(r.ptr_)), copier_(std::move(r.copier_)) {} +#endif + +#ifdef SPIMPL_HAS_AUTO_PTR + template + impl_ptr(std::auto_ptr&& u, + typename std::enable_if< + std::is_convertible::value + && is_default_manageable::value, + dummy_t_ + >::type = dummy_t_()) SPIMPL_NOEXCEPT + : ptr_(u.release(), &details::default_delete), copier_(&details::default_copy) {} +#endif + + template + impl_ptr(std::unique_ptr&& u, + typename std::enable_if< + std::is_convertible::value + && is_default_manageable::value, + dummy_t_ + >::type = dummy_t_()) SPIMPL_NOEXCEPT + : ptr_(u.release(), &details::default_delete), copier_(&details::default_copy) {} + + template + impl_ptr(std::unique_ptr&& u, C&& c, + typename std::enable_if< + std::is_convertible::value + && std::is_convertible::value + && std::is_convertible::value, + dummy_t_ + >::type = dummy_t_()) SPIMPL_NOEXCEPT + : ptr_(std::move(u)), copier_(std::forward(c)) {} + + template + impl_ptr(impl_ptr&& u, + typename std::enable_if< + std::is_convertible::value + && std::is_convertible::value + && std::is_convertible::value, + dummy_t_ + >::type = dummy_t_()) SPIMPL_NOEXCEPT + : ptr_(std::move(u.ptr_)), copier_(std::move(u.copier_)) {} + + impl_ptr& operator= (const impl_ptr& r) + { + if (this == &r) + return *this; + + return operator=(r.clone()); + } + +#ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC + impl_ptr& operator= (impl_ptr&& r) SPIMPL_NOEXCEPT = default; +#else + impl_ptr& operator= (impl_ptr&& r) SPIMPL_NOEXCEPT { + ptr_ = std::move(r.ptr_); + copier_ = std::move(r.copier_); + return *this; + } +#endif + + template + typename std::enable_if< + std::is_convertible::value + && std::is_convertible::value + && std::is_convertible::value, + impl_ptr& + >::type operator= (impl_ptr&& u) SPIMPL_NOEXCEPT + { + ptr_ = std::move(u.ptr_); + copier_ = std::move(u.copier_); + return *this; + } + + template + typename std::enable_if< + std::is_convertible::value + && std::is_convertible::value + && std::is_convertible::value, + impl_ptr& + >::type operator= (const impl_ptr& u) + { + return operator=(u.clone()); + } + + // + +#ifdef SPIMPL_HAS_AUTO_PTR + template + typename std::enable_if< + std::is_convertible::value + && is_default_manageable::value, + impl_ptr& + >::type operator= (std::auto_ptr&& u) SPIMPL_NOEXCEPT + { + return operator=(impl_ptr(std::move(u))); + } +#endif + + template + typename std::enable_if< + std::is_convertible::value + && is_default_manageable::value, + impl_ptr& + >::type operator= (std::unique_ptr&& u) SPIMPL_NOEXCEPT + { + return operator=(impl_ptr(std::move(u))); + } + + impl_ptr clone() const + { + return impl_ptr( + ptr_ ? copier_(ptr_.get()) : nullptr, + ptr_.get_deleter(), + copier_); + } + + typename std::remove_reference::type & operator*() const { return *ptr_; } + pointer operator->() const SPIMPL_NOEXCEPT { return get(); } + pointer get() const SPIMPL_NOEXCEPT { return ptr_.get(); } + + void swap(impl_ptr& u) SPIMPL_NOEXCEPT + { + using std::swap; + ptr_.swap(u.ptr_); + swap(copier_, u.copier_); + } + + pointer release() SPIMPL_NOEXCEPT { return ptr_.release(); } + + unique_ptr_type release_unique() SPIMPL_NOEXCEPT { return std::move(ptr_); } + + explicit operator bool() const SPIMPL_NOEXCEPT { return static_cast(ptr_); } + + typename std::remove_reference::type& get_deleter() SPIMPL_NOEXCEPT { return ptr_.get_deleter(); } + const typename std::remove_reference::type& get_deleter() const SPIMPL_NOEXCEPT { return ptr_.get_deleter(); } + + typename std::remove_reference::type& get_copier() SPIMPL_NOEXCEPT { return copier_; } + const typename std::remove_reference::type& get_copier() const SPIMPL_NOEXCEPT { return copier_; } + + private: + unique_ptr_type ptr_; + copier_type copier_; + }; + + + template + inline void swap(impl_ptr& l, impl_ptr& r) SPIMPL_NOEXCEPT + { + l.swap(r); + } + + + template + inline bool operator==(const impl_ptr& l, const impl_ptr& r) + { + return l.get() == r.get(); + } + + template + inline bool operator!=(const impl_ptr& l, const impl_ptr& r) + { + return !(l == r); + } + + template + inline bool operator< (const impl_ptr& l, const impl_ptr& r) + { + using P1 = typename impl_ptr::pointer; + using P2 = typename impl_ptr::pointer; + using CT = typename std::common_type::type; + return std::less()(l.get(), r.get()); + } + + template + inline bool operator> (const impl_ptr& l, const impl_ptr& r) + { + return r < l; + } + + template + inline bool operator<=(const impl_ptr& l, const impl_ptr& r) + { + return !(r < l); + } + + template + inline bool operator>=(const impl_ptr& l, const impl_ptr& r) + { + return !(l < r); + } + + template + inline bool operator==(const impl_ptr& p, std::nullptr_t) SPIMPL_NOEXCEPT + { + return !p; + } + + template + inline bool operator==(std::nullptr_t, const impl_ptr& p) SPIMPL_NOEXCEPT + { + return !p; + } + + template + inline bool operator!=(const impl_ptr& p, std::nullptr_t) SPIMPL_NOEXCEPT + { + return static_cast(p); + } + + template + inline bool operator!=(std::nullptr_t, const impl_ptr& p) SPIMPL_NOEXCEPT + { + return static_cast(p); + } + + template + inline bool operator< (const impl_ptr& l, std::nullptr_t) + { + using P = typename impl_ptr::pointer; + return std::less

()(l.get(), nullptr); + } + + template + inline bool operator< (std::nullptr_t, const impl_ptr& p) + { + using P = typename impl_ptr::pointer; + return std::less

()(nullptr, p.get()); + } + + template + inline bool operator> (const impl_ptr& p, std::nullptr_t) + { + return nullptr < p; + } + + template + inline bool operator> (std::nullptr_t, const impl_ptr& p) + { + return p < nullptr; + } + + template + inline bool operator<=(const impl_ptr& p, std::nullptr_t) + { + return !(nullptr < p); + } + + template + inline bool operator<=(std::nullptr_t, const impl_ptr& p) + { + return !(p < nullptr); + } + + template + inline bool operator>=(const impl_ptr& p, std::nullptr_t) + { + return !(p < nullptr); + } + + template + inline bool operator>=(std::nullptr_t, const impl_ptr& p) + { + return !(nullptr < p); + } + + + template + inline impl_ptr make_impl(Args&&... args) + { + return impl_ptr(new T(std::forward(args)...), &details::default_delete, &details::default_copy); + } + + + // Helpers to manage unique impl, stored in std::unique_ptr + + template + using unique_impl_ptr = std::unique_ptr; + + template + inline unique_impl_ptr make_unique_impl(Args&&... args) + { + static_assert(!std::is_array::value, "unique_impl_ptr does not support arrays"); + return unique_impl_ptr(new T(std::forward(args)...), &details::default_delete); + } +} + +namespace std { + template + struct hash> + { + using argument_type = spimpl::impl_ptr ; + using result_type = size_t; + + result_type operator()(const argument_type& p) const SPIMPL_NOEXCEPT + { + return hash()(p.get()); + } + }; +} + +#endif // SPIMPL_H_ + diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 20eaa57..5275af8 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,4 +1,4 @@ project(eedb_tests) + add_subdirectory(utils) -add_subdirectory(mocks) add_subdirectory(unit) diff --git a/tests/mocks/CMakeLists.txt b/tests/mocks/CMakeLists.txt deleted file mode 100644 index 7c334ce..0000000 --- a/tests/mocks/CMakeLists.txt +++ /dev/null @@ -1,10 +0,0 @@ -cmake_minimum_required(VERSION 3.0.2) - -project(Mocks) - -set(TEST_EXECUTABLE_NAME eedb_test_mocks ) - -#add test files -file(GLOB_RECURSE TEST_FILES *.h* *.cpp ) -add_library(${TEST_EXECUTABLE_NAME} ${TEST_FILES}) -set_target_properties(${TEST_EXECUTABLE_NAME} PROPERTIES LINKER_LANGUAGE CXX) diff --git a/tests/mocks/SessionMock.hpp b/tests/mocks/SessionMock.hpp index 70eb8e1..47fb651 100644 --- a/tests/mocks/SessionMock.hpp +++ b/tests/mocks/SessionMock.hpp @@ -3,6 +3,11 @@ #include +#include + +#include +#include + namespace eedb { class SessionMock final : public Session { // Session interface diff --git a/tests/mocks/db/UserDatabaseMock.hpp b/tests/mocks/db/UserDatabaseMock.hpp new file mode 100644 index 0000000..0f2c4cb --- /dev/null +++ b/tests/mocks/db/UserDatabaseMock.hpp @@ -0,0 +1,11 @@ +#include + +class AbstracUserDatabaseMock : public Wt::Auth::AbstractUserDatabase { + // AbstractUserDatabase interface + public: + Wt::Auth::User findWithId(const std::string & id) const {} + Wt::Auth::User findWithIdentity(const std::string & provider, const Wt::WString & identity) const {} + void addIdentity(const Wt::Auth::User & user, const std::string & provider, const Wt::WString & id) {} + Wt::WString identity(const Wt::Auth::User & user, const std::string & provider) const {} + void removeIdentity(const Wt::Auth::User & user, const std::string & provider) {} +}; diff --git a/tests/mocks/dummy.cpp b/tests/mocks/dummy.cpp deleted file mode 100644 index aabcc8c..0000000 --- a/tests/mocks/dummy.cpp +++ /dev/null @@ -1,2 +0,0 @@ -// added only to make cmake happy :( -///@todo remove if can diff --git a/tests/mocks/widgets/AuthPageMock.hpp b/tests/mocks/widgets/AuthPageMock.hpp index 331a56e..99b63d7 100644 --- a/tests/mocks/widgets/AuthPageMock.hpp +++ b/tests/mocks/widgets/AuthPageMock.hpp @@ -12,7 +12,7 @@ class AuthPageMock final : public AuthPage { MOCK_METHOD1(attachTo, void(Wt::WContainerWidget * parent)); MOCK_METHOD0(detach, void()); - MOCK_METHOD1(registerNeedVerification, void(std::function< void() > f)); + MOCK_METHOD1(registerOnNeedVerification, void(std::function< void() > f)); MOCK_METHOD1(registerOnUserWeakLogin, void(std::function< void() > f)); MOCK_METHOD1(registerOnUserStrongLogin, void(std::function< void() > f)); MOCK_METHOD1(registerOnUserLogout, void(std::function< void() > f)); diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt index e251b71..77adf56 100644 --- a/tests/unit/CMakeLists.txt +++ b/tests/unit/CMakeLists.txt @@ -2,9 +2,8 @@ cmake_minimum_required(VERSION 3.0.2) project(Tests LANGUAGES CXX) -include_directories( . ) include_directories( ../ ) -include_directories( ../../share ) + include_directories( ${eedb_app_SOURCE_DIR} ) include_directories( ${gtest_SOURCE_DIR}/include) include_directories( ${gmock_SOURCE_DIR}/include) @@ -14,8 +13,10 @@ include_directories( ${gmock_SOURCE_DIR}/include) #add test files file(GLOB_RECURSE TEST_FILES test_*.cpp ) + file(GLOB_RECURSE MOCK_FILES ../mocks/* ) + INCLUDE_DIRECTORIES(${PostgreSQL_INCLUDE_DIRS}) - add_executable( ${TEST_EXECUTABLE_NAME} ${TEST_FILES}) + add_executable( ${TEST_EXECUTABLE_NAME} ${TEST_FILES} ${MOCK_FILES} ) target_link_libraries( ${TEST_EXECUTABLE_NAME} GMock::main wt wttest eedb_db auth ${Boost_LIBRARIES} ) diff --git a/tests/unit/WidgetTest.hpp b/tests/unit/WidgetTest.hpp index adf68dc..9ad49ca 100644 --- a/tests/unit/WidgetTest.hpp +++ b/tests/unit/WidgetTest.hpp @@ -1,8 +1,8 @@ #pragma once #include -#include -#include +#include +#include class WidgetTest : public testing::Test { public: diff --git a/tests/unit/test_eedb_DefaultAuthPage.cpp b/tests/unit/test_eedb_DefaultAuthPage.cpp index d7506cd..c617a99 100644 --- a/tests/unit/test_eedb_DefaultAuthPage.cpp +++ b/tests/unit/test_eedb_DefaultAuthPage.cpp @@ -3,12 +3,15 @@ #include "utils/UniquePtrMockWrapper.hpp" #include "mocks/SessionMock.hpp" +#include "mocks/db/UserDatabaseMock.hpp" #include "mocks/widgets/MainPageMock.hpp" #include #include +#include -#include +///TODO change to mocked version +#include #include @@ -21,7 +24,7 @@ class DefaultAuthPageTest : public Test { } void createApp() { - // auto services = eedb::auth::Services(); + auto services = eedb::auth::Services(); // auto session = std::make_unique< eedb::SessionMock >(); // const eedb::auth::Services & baseAuth, @@ -35,21 +38,24 @@ class DefaultAuthPageTest : public Test { // EXPECT_CALL(*session, enviroment()).WillOnce(ReturnRef(env)); // sut = new eedb::AuthPageImpl(services, session.login()); + sut = std::make_unique< eedb::DefaultAuthPage >(services, std::move(usedDatabaseMock), login); } protected: Wt::Test::WTestEnvironment env; -// Wt::Auth::Login login; + Wt::Auth::Login login; -// std::function< void() > strongLoginCallback; + std::unique_ptr usedDatabaseMock; + + std::function< void() > strongLoginCallback; Wt::WApplication app; - eedb::DefaultAuthPage * sut; + std::unique_ptr< eedb::DefaultAuthPage > sut; }; TEST_F(DefaultAuthPageTest, createApp) { - // auto menu = dynamic_cast< Wt::WPopupMenu * >(eedb->findWidget("home.navigation.session_menu_popup")); - // auto menuItem = dynamic_cast< Wt::WMenuItem * >(eedb->findWidget("home.navigation.session_menu.logout")); - // menu->triggered().emit(menuItem); + auto menu = dynamic_cast< Wt::WPopupMenu * >(app.findWidget("home.navigation.session_menu_popup")); + auto menuItem = dynamic_cast< Wt::WMenuItem * >(app.findWidget("home.navigation.session_menu.logout")); + // menu->triggered().emit(menuItem); } // TEST(a, b) { diff --git a/tests/unit/test_eedb_DefaultHomePage.cpp b/tests/unit/test_eedb_DefaultHomePage.cpp index 6b1a631..3897a78 100644 --- a/tests/unit/test_eedb_DefaultHomePage.cpp +++ b/tests/unit/test_eedb_DefaultHomePage.cpp @@ -8,6 +8,8 @@ #include #include +#include + class DefaultHomePageTests : public WidgetTest { public: DefaultHomePageTests() : WidgetTest(), sut(std::make_unique< eedb::DefaultHomePage >(session, navigationBar.getPtr())) { diff --git a/tests/unit/test_eedb_application.cpp b/tests/unit/test_eedb_application.cpp index ece0db0..3d9562a 100644 --- a/tests/unit/test_eedb_application.cpp +++ b/tests/unit/test_eedb_application.cpp @@ -3,9 +3,10 @@ #include "mocks/SessionMock.hpp" #include "mocks/widgets/AuthPageMock.hpp" #include "mocks/widgets/MainPageMock.hpp" -#include "utils/UniquePtrMockWrapper.hpp" -#include +#include "utils/UniquePtrMockWrapper.hpp" +#include +#include #include #include @@ -47,10 +48,10 @@ class EedbApplicationTest : public Test { void expectCreateAuthPage() { EXPECT_CALL(authPageFactory, impl()).WillOnce(Return(ByMove(authPage.getPtr()))); - EXPECT_CALL(*authPage, registerNeedVerification(_)).WillOnce(SaveArg< 0 >(&callbacks[0])); - EXPECT_CALL(*authPage, registerOnUserWeakLogin(_)).WillOnce(SaveArg< 0 >(&callbacks[1])); - EXPECT_CALL(*authPage, registerOnUserStrongLogin(_)).WillOnce(SaveArg< 0 >(&callbacks[2])); - EXPECT_CALL(*authPage, registerOnUserLogout(_)).WillOnce(SaveArg< 0 >(&callbacks[3])); + EXPECT_CALL(*authPage, registerOnNeedVerification(_)).WillOnce(SaveArg< 0 >(&_needVerificationCB)); + EXPECT_CALL(*authPage, registerOnUserWeakLogin(_)).WillOnce(SaveArg< 0 >(&_weakLoginCB)); + EXPECT_CALL(*authPage, registerOnUserStrongLogin(_)).WillOnce(SaveArg< 0 >(&_stringLoginCB)); + EXPECT_CALL(*authPage, registerOnUserLogout(_)).WillOnce(SaveArg< 0 >(&_userLogoutCB)); EXPECT_CALL(*authPage, attachTo(Ne(nullptr))); EXPECT_CALL(*authPage, processEnvironment()); } @@ -64,7 +65,10 @@ class EedbApplicationTest : public Test { protected: Wt::Test::WTestEnvironment env; - std::array< std::function< void() >, 4 > callbacks; + std::function< void() > _stringLoginCB; + std::function< void() > _weakLoginCB; + std::function< void() > _userLogoutCB; + std::function< void() > _needVerificationCB; UniquePtrMockWrapper< eedb::AuthPageMock > authPage; AuthPageFactory authPageFactory; @@ -79,10 +83,10 @@ TEST_F(EedbApplicationTest, createApp) {} TEST_F(EedbApplicationTest, strongLoginCreatesMainPage) { expectCreateHomePage(); - callbacks[2](); + _stringLoginCB(); } TEST_F(EedbApplicationTest, weakLoginCreatesMainPage) { expectCreateHomePage(); - callbacks[1](); + _weakLoginCB(); }