OIDCSessionImpl_test.h

#ifndef TENDUKE_TEST_OIDC_OIDCSESSIONIMPL_TEST_H
#define TENDUKE_TEST_OIDC_OIDCSESSIONIMPL_TEST_H
 
#include "oidc/session/OIDCSessionImpl.h"
#include "oidc/session/DefaultOIDCSessionEventListener.h"
#include "oauth/OAuthInvalidGrant.h"
 
#include "mocks/ClockMock.h"
#include "mocks/OIDCClientMock.h"
#include "mocks/OIDCLoginMock.h"
#include "mocks/OIDCLoginRequestMock.h"
#include "mocks/OIDCRefreshRequestMock.h"
 
#include "gmock/gmock.h"
#include "gtest/gtest.h"
 
#include <thread>
 
using tenduke::oauth::OAuthInvalidGrant;
using tenduke::oauth::TOKEN_DOES_NOT_EXPIRE;
using tenduke::oidc::IdToken;
using tenduke::oidc::DefaultOIDCSessionEventListener;
using tenduke::oidc::OIDCSessionImpl;
using tenduke::oidc::OIDCState;
using tenduke::test::mocks::ClockMock;
using tenduke::test::mocks::OIDCClientMock;
using tenduke::test::mocks::OIDCLoginMock;
using tenduke::test::mocks::OIDCLoginRequestMock;
using tenduke::test::mocks::OIDCRefreshRequestMock;
 
using ::testing::_;
using ::testing::Return;
using ::testing::Throw;
 
namespace tenduke { namespace test { namespace oidc {
 
class SessionEventListener : public ::DefaultOIDCSessionEventListener
{
public:
    void loginStarting() override
    {
        DefaultOIDCSessionEventListener::loginStarting();
        loginStartingCalled++;
    }
 
    void loginComplete(const OIDCState &state) override
    {
        DefaultOIDCSessionEventListener::loginComplete(state);
        loginCompleteAccessTokens.emplace_back(state.getAccessToken());
    }
 
    void refreshComplete(const OIDCState &state) override
    {
        DefaultOIDCSessionEventListener::refreshComplete(state);
        refreshCompleteAccessTokens.emplace_back(state.getAccessToken());
    }
 
    int loginStartingCalled = 0;
    std::vector<std::string> loginCompleteAccessTokens;
    std::vector<std::string> refreshCompleteAccessTokens;
};
 
class StateRecorder
{
public:
    void addAction(const std::string &action)
    {
        std::lock_guard<std::recursive_mutex> lock(mutex);
        actions.emplace_back(action);
    }
 
    std::vector<std::string> getActions()
    {
        std::lock_guard<std::recursive_mutex> lock(mutex);
        return actions;
    }
 
    std::vector<std::string> actions;
private:
    std::recursive_mutex mutex;
};
 
class FakeOIDCLoginRequest : public tenduke::oidc::OIDCLoginRequest
{
public:
    explicit FakeOIDCLoginRequest(const std::chrono::milliseconds &sleepFor)
    : sleepFor(sleepFor), abortCalled(0), recorder(nullptr)
    {}
    explicit FakeOIDCLoginRequest(const std::chrono::milliseconds &sleepFor, const std::shared_ptr<StateRecorder> &detector)
    : sleepFor(sleepFor), abortCalled(0), recorder(detector)
    {}
 
    ~FakeOIDCLoginRequest() override
    {
        addAction("destroyed");
    }
 
    std::unique_ptr<::OIDCState> execute() override
    {
        addAction("execute-before-sleep");
        std::this_thread::sleep_for(sleepFor);
        addAction("execute-after-sleep");
        return std::unique_ptr<::OIDCState>(new ::OIDCState("at", "rt", 200, false, {}, ::IdToken({}, {})));
    }
    void abort() override
    {
        addAction("abort");
        abortCalled += 1;
    }
 
    void addAction(const std::string &action)
    {
        if (recorder != nullptr) recorder->addAction(action);
    }
 
    std::chrono::milliseconds sleepFor;
    volatile std::uint64_t abortCalled;
    std::shared_ptr<StateRecorder> recorder;
};
 
class OIDCSessionImplTest : public ::testing::Test
{
protected:
    void SetUp() override
    {
        clock = ::ClockMock::createShared();
        oidcLogin = ::OIDCLoginMock::createShared();
        oidcClient = ::OIDCClientMock::createShared();
        sessionEventListener = std::make_shared<SessionEventListener>();
 
        EXPECT_CALL(*clock, epochSeconds()).WillRepeatedly(::Return(100));
    }
 
    std::shared_ptr<::ClockMock> clock;
    std::shared_ptr<::OIDCLoginMock> oidcLogin;
    std::shared_ptr<::OIDCClientMock> oidcClient;
    std::shared_ptr<SessionEventListener> sessionEventListener;
 
    // Helpers:
    std::shared_ptr<::OIDCSessionImpl> session(
            std::unique_ptr<::OIDCState> state,
            std::uint64_t validitySafetyMarginS = 10,
            std::chrono::milliseconds loginTimeout = std::chrono::milliseconds(0)
    )
    {
        return std::make_shared<::OIDCSessionImpl>(
                std::move(state),
                oidcLogin,
                oidcClient,
                clock,
                sessionEventListener,
                validitySafetyMarginS,
                loginTimeout
        );
    }
    std::shared_ptr<::OIDCSessionImpl> session(
            const ::OIDCState &state,
            std::uint64_t validitySafetyMarginS = 10,
            std::chrono::milliseconds loginTimeout = std::chrono::milliseconds(0)
    )
    {
        return session(std::unique_ptr<::OIDCState>(new ::OIDCState(state)), validitySafetyMarginS, loginTimeout);
    }
    std::shared_ptr<::OIDCSessionImpl> session_without_state()
    {
        return session(nullptr);
    }
    std::shared_ptr<::OIDCSessionImpl> session_without_access_token()
    {
        return session(::OIDCState("", "", -1, false, {}, ::IdToken({}, {})));
    }
    std::shared_ptr<::OIDCSessionImpl> infinite_session(std::chrono::milliseconds loginTimeout = std::chrono::milliseconds (0))
    {
        return session(
                ::OIDCState("at", "", ::TOKEN_DOES_NOT_EXPIRE, true, {}, ::IdToken({}, {})),
                10,
                loginTimeout
        );
    }
    std::shared_ptr<::OIDCSessionImpl> session_that_expires_at(const std::int64_t expiresAt, const bool refreshable = true)
    {
        return session(::OIDCState("at", (refreshable ? "rt" : ""), expiresAt, false, {}, ::IdToken({}, {})));
    }
    ::OIDCState * createRefreshedState()
    {
        return new ::OIDCState(
            "at-new",
            "rt-new",
            200,
            false,
            {},
            ::IdToken({}, {})
        );
    }
    void stubSuccessfulRefresh()
    {
        auto refreshRequest = new ::OIDCRefreshRequestMock();
        auto refreshedState = createRefreshedState();
 
        EXPECT_CALL(*oidcClient, refresh(::_)).WillOnce(::Return(std::unique_ptr<::OIDCRefreshRequestMock>(refreshRequest)));
        EXPECT_CALL(*refreshRequest, execute()).WillOnce(::Return(std::unique_ptr<::OIDCState>(refreshedState)));
    }
    void stubOAuthInvalidGrantRefresh()
    {
        auto refreshRequest = new ::OIDCRefreshRequestMock();
 
        EXPECT_CALL(*oidcClient, refresh(::_)).WillOnce(::Return(std::unique_ptr<::OIDCRefreshRequestMock>(refreshRequest)));
        EXPECT_CALL(*refreshRequest, execute()).WillOnce(::Throw(::OAuthInvalidGrant(oauth::OAuthException::REFRESH_REQUEST, "", "")));
    }
    ::OIDCLoginRequestMock * stubLogin()
    {
        auto loginRequest = new ::OIDCLoginRequestMock();
 
        EXPECT_CALL(*oidcLogin, login()).WillOnce(::Return(std::unique_ptr<::OIDCLoginRequestMock>(loginRequest)));
        return loginRequest;
    }
 
    ::OIDCLoginRequestMock * stubSuccessfulLogin()
    {
        auto loginRequest = stubLogin();
        auto state = createRefreshedState();
 
        EXPECT_CALL(*loginRequest, execute()).WillOnce(::Return(std::unique_ptr<::OIDCState>(state)));
 
        return loginRequest;
    }
};
 
}}}
 
#endif //TENDUKE_TEST_OIDC_OIDCSESSIONIMPL_TEST_H