MockHTTP2Connection.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */
#ifndef ALEXA_CLIENT_SDK_ACL_TEST_TRANSPORT_MOCKHTTP2CONNECTION_H_
#define ALEXA_CLIENT_SDK_ACL_TEST_TRANSPORT_MOCKHTTP2CONNECTION_H_

#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <deque>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_set>

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <ACL/Transport/MessageConsumerInterface.h>
#include <AVSCommon/Utils/PromiseFuturePair.h>
#include <AVSCommon/Utils/HTTP/HttpResponseCode.h>
#include <AVSCommon/Utils/HTTP2/HTTP2ConnectionInterface.h>

#include "MockHTTP2Request.h"

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace http2 {
namespace test {

class MockHTTP2Connection : public HTTP2ConnectionInterface {
public:
    MockHTTP2Connection(std::string dURL, std::string pingURL, bool delegateToReal = true);

    ~MockHTTP2Connection() = default;

    MOCK_METHOD1(createAndSendRequest, std::shared_ptr<HTTP2RequestInterface>(const HTTP2RequestConfig& config));
    MOCK_METHOD0(disconnect, void());
    void addObserver(std::shared_ptr<avsCommon::utils::http2::HTTP2ConnectionObserverInterface> observer);
    void removeObserver(std::shared_ptr<avsCommon::utils::http2::HTTP2ConnectionObserverInterface> observer);

    std::shared_ptr<HTTP2RequestInterface> createAndSendRequestConcrete(const HTTP2RequestConfig& config);

    bool isRequestQueueEmpty();

    std::shared_ptr<MockHTTP2Request> waitForRequest(std::chrono::milliseconds timeout, unsigned requestNum = 1);

    std::shared_ptr<MockHTTP2Request> dequeRequest();

    void setWaitRequestHeader(const std::string& matchString);

    bool waitForRequestWithHeader(std::chrono::milliseconds timeout);

    std::shared_ptr<MockHTTP2Request> waitForPostRequest(const std::chrono::milliseconds timeout);

    std::shared_ptr<MockHTTP2Request> waitForPingRequest(const std::chrono::milliseconds timeout);

    bool respondToDownchannelRequests(
        long responseCode,
        bool sendResponseFinished,
        const std::chrono::milliseconds timeout);

    void setResponseToPOSTRequests(http::HTTPResponseCode responseCode);

    std::shared_ptr<MockHTTP2Request> getDownchannelRequest(
        std::chrono::milliseconds timeout = std::chrono::milliseconds(0));

    bool isPauseOnSendReceived(std::chrono::milliseconds timeout = std::chrono::milliseconds(0));

    /*
     * Get the number of POST requests in the queue.
     *
     * @return The number of POST requests in the queue.
     */
    std::size_t getPostRequestsNum();

    /*
     * Get the number of HTTP2 requests in the queue.
     *
     * @return The number of HTTP2 requests in the queue.
     */
    std::size_t getRequestsNum();

    /*
     * Get the number of downchannel requests in the queue.
     *
     * @return The number of downchannel requests in the queue.
     */
    std::size_t getDownchannelRequestsNum();

    /*
     * Pop the oldest HTTP2 POST request from queue if it is not empty, otherwise wait for at most @c timeout for a
     * request to be enqueued
     *
     * @return The oldest HTTP2 POST request in the queue or nullptr if the timeout expires
     */
    std::shared_ptr<MockHTTP2Request> dequePostRequest(const std::chrono::milliseconds timeout);

    /*
     * Pop the oldest HTTP2 POST request from queue.
     *
     * @return The oldest HTTP2 POST request in the queue.
     */
    std::shared_ptr<MockHTTP2Request> dequePostRequest();

    /*
     * Pop the oldest HTTP2 Ping request from queue.
     *
     * @return The oldest HTTP2 Ping request in the queue.
     */
    std::shared_ptr<MockHTTP2Request> dequePingRequest();

    /*
     * Retrieve the maximum number of POST requests in the queue at any given time.
     *
     * @return The maximum number of POST requests in the queue at any given time.
     */
    std::size_t getMaxPostRequestsEnqueud();

private:
    std::deque<std::shared_ptr<MockHTTP2Request>> m_requestQueue;

    std::mutex m_requestMutex;

    std::condition_variable m_requestCv;

    std::string m_downchannelURL;

    std::string m_pingURL;

    std::deque<std::shared_ptr<MockHTTP2Request>> m_downchannelRequestQueue;

    std::mutex m_downchannelRequestMutex;

    // Used to wake a thread that is waiting for a downchannel request.
    std::condition_variable m_downchannelRequestCv;

    std::deque<std::shared_ptr<MockHTTP2Request>> m_postRequestQueue;

    std::mutex m_postRequestMutex;

    std::condition_variable m_requestPostCv;

    std::deque<std::shared_ptr<MockHTTP2Request>> m_pingRequestQueue;

    std::mutex m_observersMutex;

    std::unordered_set<std::shared_ptr<avsCommon::utils::http2::HTTP2ConnectionObserverInterface>> m_observers;

    std::mutex m_pingRequestMutex;

    // Used to wake a thread that is waiting for a Ping request.
    std::condition_variable m_pingRequestCv;

    std::string m_headerMatch;

    std::condition_variable m_requestHeaderCv;

    PromiseFuturePair<void> m_receivedPauseOnSend;

    http::HTTPResponseCode m_postResponseCode;

    std::size_t m_maxPostRequestsEnqueued;

    static const unsigned READ_DATA_BUF_SIZE = 100;
};

}  // namespace test
}  // namespace http2
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ACL_TEST_TRANSPORT_MOCKHTTP2CONNECTION_H_