OAuthPKCEFlow_test.h

#ifndef TENDUKE_TEST_OAUTHPKCEFLOW_TEST_H
#define TENDUKE_TEST_OAUTHPKCEFLOW_TEST_H
 
#include "oauth/pkce/OAuthPKCEFlow.h"
#include "utl/DefaultBase64Encoder.h"
#include "utl/random/RandomURLSafeString.h"
 
#include "mocks/MessageDigestMock.h"
#include "mocks/HTTPCallMock.h"
#include "mocks/HTTPClientMock.h"
#include "mocks/JSONObjectMock.h"
#include "mocks/JSONParserMock.h"
#include "mocks/JSONNumberMock.h"
#include "mocks/JSONStringMock.h"
#include "mocks/ClockMock.h"
#include "mocks/RandomBytesMock.h"
#include "mocks/URLMock.h"
#include "mocks/URLEncoderMock.h"
#include "mocks/URLParserMock.h"
#include "utils/BinaryDataUtils.h"
 
#include "gmock/gmock.h"
#include "gtest/gtest.h"
 
#include <cstring>
 
namespace xdcrypto = tenduke::crypto;
namespace xdhttp = tenduke::http;
namespace xdnet = tenduke::net;
namespace xdoauth = tenduke::oauth;
namespace xdpkce = tenduke::oauth::pkce;
namespace xdutl = tenduke::utl;
 
namespace xdmock = tenduke::test::mocks;
 
using tenduke::http::HTTPResponse;
using tenduke::json::JSONElement;
using tenduke::test::mocks::HTTPCallMock;
using tenduke::test::mocks::JSONObjectMock;
using tenduke::test::mocks::JSONNumberMock;
using tenduke::test::mocks::JSONStringMock;
using tenduke::test::utils::makeFixedSizeBinaryData;
 
 
using ::testing::_;
using ::testing::StrEq;
 
using ::testing::Invoke;
using ::testing::Return;
using ::testing::ReturnRef;
 
namespace tenduke { namespace test { namespace oauth {
 
void generateRandomBytes(unsigned char * buffer, std::size_t len)
{
    switch (len) {
        case 16:
            std::strcpy((char *) buffer, "simulated-state"); break;
        case 64:
            std::strcpy((char *) buffer, "simulated-code-generator-value-on-which-sha256-will-be-applied."); break;
    }
}
 
static void fakeSha256(unsigned char * digest)
{
    xdmock::generateFakeSha256Hash(digest, "0123456789ABCDEF0123456789ABCDEF");
}
 
class OAuthPKCEFlowTest : public ::testing::Test
{
protected:
    void SetUp() override
    {
        httpClient = std::shared_ptr<xdmock::HTTPClientMock>(new xdmock::HTTPClientMock());
        urlParser = std::shared_ptr<xdmock::URLParserMock>(new xdmock::URLParserMock());
        jsonParser = std::shared_ptr<xdmock::JSONParserMock>(new xdmock::JSONParserMock());
        base64Encoder = std::shared_ptr<xdutl::Base64Encoder>(new xdutl::DefaultBase64Encoder());
        messageDigestFactory = std::shared_ptr<xdmock::MessageDigestFactoryMock>(new xdmock::MessageDigestFactoryMock());
        clock = std::shared_ptr<xdmock::ClockMock>(new xdmock::ClockMock());
        randomBytes = std::shared_ptr<xdmock::RandomBytesMock>(new xdmock::RandomBytesMock());
        urlEncoder = std::shared_ptr<xdmock::URLEncoderMock>(new xdmock::URLEncoderMock());
 
        oauth = std::unique_ptr<xdpkce::OAuthPKCEFlow>(new xdpkce::OAuthPKCEFlow(
                std::shared_ptr<xdoauth::OAuthConfiguration>(new xdoauth::OAuthConfiguration("/authz", "/token", "client-id", "", "/redir", tenduke::oauth::OAuthClientConfiguration::PKCE)),
                httpClient,
                urlParser,
                jsonParser,
                base64Encoder,
                messageDigestFactory,
                clock,
                std::shared_ptr<tenduke::utl::random::RandomUrlSafeString>(new tenduke::utl::random::RandomUrlSafeString(randomBytes))
        ));
 
        EXPECT_CALL(*randomBytes, generate(_, _))
                .WillRepeatedly(Invoke(generateRandomBytes));
        EXPECT_CALL(*httpClient, request())
                .WillRepeatedly(Return(xdhttp::HTTPRequestBuilder(urlEncoder, httpClient.get())));
        EXPECT_CALL(*urlEncoder, encode(_))
                .WillRepeatedly(::testing::ReturnArg<0>());
    }
 
    void stubForBuildAuthorizationUrl()
    {
        digest = new xdmock::MessageDigestMock();
        EXPECT_CALL(*messageDigestFactory, create(xdcrypto::MessageDigest::SHA256))
                .Times(1)
                .WillOnce(Return(std::unique_ptr<xdcrypto::MessageDigest>(digest)));
        EXPECT_CALL(*digest, update(_, _))
                .Times(1)
                .WillOnce(Return(digest));
        EXPECT_CALL(*digest, digestTo(_))
                .Times(1)
                .WillOnce(Invoke(fakeSha256));
    }
 
    void stubForHandleCallback(const std::string &redirectUri)
    {
        url = new xdmock::URLMock();
        EXPECT_CALL(*urlParser, from(StrEq(redirectUri)))
            .Times(1)
            .WillOnce(Return(std::unique_ptr<xdnet::URL>(url)));
    }
 
    void stubForTokenResponse()
    {
        auto responseBody = ::makeFixedSizeBinaryData("simulated-response-body");
        auto tokenResponse = new ::HTTPResponse(200, {}, std::move(responseBody));
 
        auto tokenRequestCall = new ::HTTPCallMock();
        EXPECT_CALL(*httpClient, request()).WillRepeatedly(::Return(xdhttp::HTTPRequestBuilder(urlEncoder, httpClient.get())));
        EXPECT_CALL(*httpClient, call(::_)).WillOnce(::Return(std::unique_ptr<::HTTPCallMock>(tokenRequestCall)));
        EXPECT_CALL(*tokenRequestCall, execute()).WillOnce(::Return(std::unique_ptr<::HTTPResponse>(tokenResponse)));
 
        auto json = ::JSONObjectMock::create();
        auto accessToken = ::JSONStringMock::createShared("simulated-access-token");
        auto refreshToken = ::JSONStringMock::createShared("simulated-refresh-token");
        auto expiresIn = ::JSONNumberMock::createShared(42);
        auto additionalProperty1 = ::JSONStringMock::createShared("value-1");
        auto additionalProperty2 = ::JSONStringMock::createShared("value-2");
        additionalTokenResponseProperties.emplace("name-1", additionalProperty1);
        additionalTokenResponseProperties.emplace("name-2", additionalProperty2);
 
        EXPECT_CALL(*jsonParser, from("simulated-response-body")).WillOnce(::Return(std::unique_ptr<::JSONObjectMock>(json)));
        EXPECT_CALL(*json, removeProperty("access_token")).WillOnce(::Return(accessToken));
        EXPECT_CALL(*json, removeProperty("refresh_token")).WillOnce(::Return(refreshToken));
        EXPECT_CALL(*json, removeProperty("expires_in")).WillOnce(::Return(expiresIn));
        EXPECT_CALL(*json, getProperties()).WillOnce(::ReturnRef(additionalTokenResponseProperties));
 
        EXPECT_CALL(*clock, epochSeconds()).WillRepeatedly(::Return(100));
    }
 
    xdmock::MessageDigestMock *digest;
    xdmock::URLMock *url;
 
    std::map<std::string, std::shared_ptr<::JSONElement>> additionalTokenResponseProperties;
    std::shared_ptr<xdmock::HTTPClientMock> httpClient;
    std::shared_ptr<xdmock::URLParserMock> urlParser;
    std::shared_ptr<xdmock::JSONParserMock> jsonParser;
    std::shared_ptr<xdutl::Base64Encoder> base64Encoder;
    std::shared_ptr<xdmock::MessageDigestFactoryMock> messageDigestFactory;
    std::shared_ptr<xdmock::ClockMock> clock;
    std::shared_ptr<xdmock::RandomBytesMock> randomBytes;
    std::shared_ptr<xdmock::URLEncoderMock> urlEncoder;
 
    std::unique_ptr<xdpkce::OAuthPKCEFlow> oauth;
}; // OAuthPKCEFlowTest
}}} // namespace
 
 
#endif //TENDUKE_TEST_OAUTHPKCEFLOW_TEST_H