DefaultOAuthDeviceFlowAuthorizationRequest_test.h

#ifndef TENDUKE_TEST_OAUTH_DEVICE_DEFAULTOAUTHDEVICEFLOWAUTHORIZATIONREQUESTTEST_H
#define TENDUKE_TEST_OAUTH_DEVICE_DEFAULTOAUTHDEVICEFLOWAUTHORIZATIONREQUESTTEST_H
 
#include "oauth/device/DefaultOAuthDeviceFlowAuthorizationRequest.h"
 
#include "mocks/ClockMock.h"
#include "mocks/HTTPCallMock.h"
#include "mocks/HTTPClientMock.h"
#include "mocks/JSONNumberMock.h"
#include "mocks/JSONObjectMock.h"
#include "mocks/JSONParserMock.h"
#include "mocks/JSONStringMock.h"
#include "mocks/URLEncoderMock.h"
#include "utils/BinaryDataUtils.h"
 
#include "gtest/gtest.h"
#include "gmock/gmock.h"
 
 
using tenduke::http::HTTPRequestBuilder;
using tenduke::http::HTTPResponse;
using tenduke::http::HTTPResponseToException;
using tenduke::json::JSONElement;
using tenduke::oauth::OAuthConfiguration;
using tenduke::oauth::device::DefaultOAuthDeviceFlowAuthorizationRequest;
using tenduke::test::mocks::ClockMock;
using tenduke::test::mocks::HTTPCallMock;
using tenduke::test::mocks::HTTPClientMock;
using tenduke::test::mocks::JSONNumberMock;
using tenduke::test::mocks::JSONObjectMock;
using tenduke::test::mocks::JSONParserMock;
using tenduke::test::mocks::JSONStringMock;
using tenduke::test::mocks::URLEncoderMock;
using tenduke::test::utils::makeFixedSizeBinaryData;
 
using ::testing::_;
using ::testing::Return;
using ::testing::ReturnRef;
 
namespace tenduke { namespace test {namespace oauth { namespace device {
 
class FakeRequest : public ::DefaultOAuthDeviceFlowAuthorizationRequest
{
public:
    FakeRequest(
            const std::string &scope,
            const std::map<std::string, std::string> &additionalParameters,
            uint64_t timeoutS,
            const std::shared_ptr<const tenduke::oauth::OAuthConfiguration> &configuration,
            const std::shared_ptr<tenduke::time::Clock> &clock,
            const std::shared_ptr<const tenduke::http::HTTPClient> &httpClient,
            const std::shared_ptr<const tenduke::http::HTTPResponseToException> &throwException,
            const std::shared_ptr<const tenduke::json::JSONParser> &jsonParser
    ) : DefaultOAuthDeviceFlowAuthorizationRequest(
            scope,
            additionalParameters,
            timeoutS,
            configuration,
            clock,
            httpClient,
            throwException,
            jsonParser
    )
    {}
 
    std::vector<std::chrono::milliseconds> sleepTimes;
 
    void letMeSleep()
    {
        ::DefaultOAuthDeviceFlowAuthorizationRequest::sleepFor(std::chrono::milliseconds(1));
    }
 
protected:
    void sleepFor(std::chrono::milliseconds slumbertime) override
    {
        sleepTimes.emplace_back(slumbertime);
    }
};
 
class DefaultOAuthDeviceFlowAuthorizationRequestTest : public ::testing::Test
{
protected:
    FakeRequest * mkRequest(const std::uint64_t localTimeoutS = 100)
    {
        std::map<std::string, std::string> params;
        params.emplace("key-1", "value-1");
        params.emplace("key-2", "value-2");
 
        return new FakeRequest(
                "profile",
                params,
                localTimeoutS,
                std::make_shared<::OAuthConfiguration>(
                        "/authz",
                        "/token",
                        "cl-id",
                        "",
                        "",
                        ::OAuthConfiguration::DEVICE,
                        "/device"
                ),
                clock,
                httpClient,
                std::make_shared<::HTTPResponseToException>(),
                jsonParser
        );
    }
 
    void SetUp() override
    {
        clock = ::ClockMock::createShared();
        httpClient = ::HTTPClientMock::createShared();
        jsonParser = ::JSONParserMock::createShared();
        urlEncoder = ::URLEncoderMock::createShared();
 
        request.reset(mkRequest());
    }
 
    std::shared_ptr<FakeRequest> request;
    std::shared_ptr<::ClockMock> clock;
    std::shared_ptr<::HTTPClientMock> httpClient;
    std::shared_ptr<::JSONParserMock> jsonParser;
    std::shared_ptr<::URLEncoderMock> urlEncoder;
 
    std::map<std::string, std::shared_ptr<::JSONElement>> tokenResponseProps;
 
    void stubAuthorizationRequest(
            const std::int64_t expiresIn = 42,
            const std::int64_t interval = 69
    )
    {
        auto document = ::JSONObjectMock::create();
        EXPECT_CALL(*jsonParser, from("successful-authorization-request")).WillOnce(::Return(std::unique_ptr<::JSONObjectMock>(document)));
        EXPECT_CALL(*document, getProperty("device_code")).WillRepeatedly(::Return(::JSONStringMock::createShared("-device-code-")));
        EXPECT_CALL(*document, getProperty("user_code")).WillRepeatedly(::Return(::JSONStringMock::createShared("-user-code-")));
        EXPECT_CALL(*document, getProperty("verification_uri")).WillRepeatedly(::Return(::JSONStringMock::createShared("/verify")));
        EXPECT_CALL(*document, getProperty("verification_uri_complete")).WillRepeatedly(::Return(::JSONStringMock::createShared("/verify-complete")));
        EXPECT_CALL(*document, getProperty("expires_in")).WillRepeatedly(::Return(::JSONNumberMock::createShared(expiresIn)));
        if (interval > 0) {
            EXPECT_CALL(*document, getProperty("interval")).WillRepeatedly(::Return(::JSONNumberMock::createShared(interval)));
        }
        else {
            EXPECT_CALL(*document, getProperty("interval")).WillRepeatedly(::Return(nullptr));
        }
    }
    void stubSuccessfulTokenRequest()
    {
        auto document = ::JSONObjectMock::create();
        EXPECT_CALL(*jsonParser, from("successful-token-request")).WillOnce(::Return(std::unique_ptr<::JSONObjectMock>(document)));
        EXPECT_CALL(*document, removeProperty("access_token")).WillOnce(::Return(::JSONStringMock::createShared("at")));
        EXPECT_CALL(*document, removeProperty("refresh_token")).WillOnce(::Return(::JSONStringMock::createShared("rt")));
        EXPECT_CALL(*document, removeProperty("expires_in")).WillOnce(::Return(::JSONNumberMock::createShared(77)));
 
        tokenResponseProps.emplace("key-1", ::JSONStringMock::createShared("value-1"));
        tokenResponseProps.emplace("key-2", ::JSONStringMock::createShared("value-2"));
 
        EXPECT_CALL(*document, getProperties()).WillOnce(::ReturnRef(tokenResponseProps));
    }
    void stubErrorResponses(
            const unsigned int numTimes,
            const std::string jsonPayload,
            const std::string error
    ) {
        auto &documentStub = EXPECT_CALL(*jsonParser, from(jsonPayload));
        for (unsigned int i = 0; i < numTimes; i++) {
            auto document = ::JSONObjectMock::create();
            documentStub.WillOnce(::Return(std::unique_ptr<::JSONObjectMock>(document)));
            EXPECT_CALL(*document, getProperty("error")).WillRepeatedly(::Return(::JSONStringMock::createShared(error)));
            EXPECT_CALL(*document, getProperty("error_description")).WillRepeatedly(::Return(::JSONStringMock::createShared("simulated_error")));
        }
    }
    void stubAuthorizationPending(const unsigned int numTimes) {
        stubErrorResponses(numTimes, "authorization-pending", "authorization_pending");
    }
    void stubSlowDown(const unsigned int numTimes)
    {
        stubErrorResponses(numTimes, "slow-down", "slow_down");
    }
};
}}}}
 
 
#endif //TENDUKE_TEST_OAUTH_DEVICE_DEFAULTOAUTHDEVICEFLOWAUTHORIZATIONREQUESTTEST_H