MockDirectiveHandler.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_ADSL_TEST_COMMON_MOCKDIRECTIVEHANDLER_H_
#define ALEXA_CLIENT_SDK_ADSL_TEST_COMMON_MOCKDIRECTIVEHANDLER_H_

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

#include <AVSCommon/SDKInterfaces/DirectiveHandlerInterface.h>
#include <AVSCommon/AVS/NamespaceAndName.h>

namespace alexaClientSDK {
namespace adsl {
namespace test {

class DirectiveHandlerMockAdapter : public avsCommon::sdkInterfaces::DirectiveHandlerInterface {
public:
    void preHandleDirective(
        std::shared_ptr<avsCommon::avs::AVSDirective> directive,
        std::unique_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface> result) override;

    virtual void preHandleDirective(
        std::shared_ptr<avsCommon::avs::AVSDirective> directive,
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface> result) = 0;
};

class MockDirectiveHandler : public DirectiveHandlerMockAdapter {
public:
    static std::shared_ptr<testing::NiceMock<MockDirectiveHandler>> create(
        avsCommon::avs::DirectiveHandlerConfiguration config,
        std::chrono::milliseconds handlingTimeMs = DEFAULT_HANDLING_TIME_MS);

    MockDirectiveHandler(
        avsCommon::avs::DirectiveHandlerConfiguration config,
        std::chrono::milliseconds handlingTimeMs);

    ~MockDirectiveHandler();

    void mockHandleDirectiveImmediately(std::shared_ptr<avsCommon::avs::AVSDirective> directive);

    void mockPreHandleDirective(
        std::shared_ptr<avsCommon::avs::AVSDirective> directive,
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface> result);

    bool mockHandleDirective(const std::string& messageId);

    void mockCancelDirective(const std::string& messageId);

    void mockOnDeregistered();

    void doHandleDirective(const std::string& messageId);

    void doPreHandlingFailed(
        std::shared_ptr<avsCommon::avs::AVSDirective> directive,
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface> result);

    void doHandlingCompleted();

    bool doHandlingFailed(const std::string& messageId);

    void shutdown();

    bool waitUntilPreHandling(std::chrono::milliseconds timeout = DEFAULT_DONE_TIMEOUT_MS);

    bool waitUntilHandling(std::chrono::milliseconds timeout = DEFAULT_DONE_TIMEOUT_MS);

    bool waitUntilCanceling(std::chrono::milliseconds timeout = DEFAULT_DONE_TIMEOUT_MS);

    bool waitUntilCompleted(std::chrono::milliseconds timeout = DEFAULT_DONE_TIMEOUT_MS);

    std::chrono::milliseconds m_handlingTimeMs;

    std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface> m_result;

    std::shared_ptr<avsCommon::avs::AVSDirective> m_directive;

    std::thread m_doHandleDirectiveThread;

    std::mutex m_mutex;

    std::condition_variable m_wakeNotifier;

    bool m_isCompleted;

    bool m_isShuttingDown;

    std::promise<void> m_preHandlingPromise;

    std::future<void> m_preHandlingFuture;

    std::promise<void> m_handlingPromise;

    std::future<void> m_handlingFuture;

    std::promise<void> m_cancelingPromise;

    std::shared_future<void> m_cancelingFuture;

    std::promise<void> m_completedPromise;

    std::future<void> m_completedFuture;

    MOCK_METHOD1(handleDirectiveImmediately, void(std::shared_ptr<avsCommon::avs::AVSDirective>));
    MOCK_METHOD2(
        preHandleDirective,
        void(
            std::shared_ptr<avsCommon::avs::AVSDirective>,
            std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface>));
    MOCK_METHOD1(handleDirective, bool(const std::string&));
    MOCK_METHOD1(cancelDirective, void(const std::string&));
    MOCK_METHOD0(onDeregistered, void());
    MOCK_CONST_METHOD0(getConfiguration, avsCommon::avs::DirectiveHandlerConfiguration());

    static const std::chrono::milliseconds DEFAULT_HANDLING_TIME_MS;

    static const std::chrono::milliseconds DEFAULT_DONE_TIMEOUT_MS;
};

}  // namespace test
}  // namespace adsl
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ADSL_TEST_COMMON_MOCKDIRECTIVEHANDLER_H_