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_