/*
 * 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.
 */

#include <chrono>
#include <future>
#include <memory>
#include <string>
#include <thread>
#include <gtest/gtest.h>
#include <gmock/gmock.h>

#include <AVSCommon/AVS/Attachment/AttachmentManager.h>
#include <AVSCommon/SDKInterfaces/MockDirectiveHandlerResult.h>

#include "ADSL/DirectiveRouter.h"
#include "MockDirectiveHandler.h"

using namespace ::testing;

namespace alexaClientSDK {
namespace adsl {
namespace test {

using namespace avsCommon;
using namespace avsCommon::avs;
using namespace avsCommon::avs::attachment;
using namespace avsCommon::avs::directiveRoutingRule;

/// Generic messageId used for tests.
static const std::string MESSAGE_ID_0_0("Message_0_0");

/// Generic MessageId used for test.
static const std::string MESSAGE_ID_0_1("Message_0_1");

/// Generic MessageId used for test.
static const std::string MESSAGE_ID_0_2("Message_0_2");

/// Generic MessageId used for tests.
static const std::string MESSAGE_ID_1_0("Message_1_0");

/// Generic MessageId used for test.
static const std::string MESSAGE_ID_2_0("Message_2_0");

/// Generic DialogRequestId used for tests.
static const std::string DIALOG_REQUEST_ID_0("DialogRequestId_0");

/// An unparsed directive for test.
static const std::string UNPARSED_DIRECTIVE("unparsedDirectiveForTest");

/// A paylaod for test;
static const std::string PAYLOAD_TEST("payloadForTest");

/// A generic namespace string for tests.
static const std::string NAMESPACE_0("namespace_0");

/// A generic namespace string for tests.
static const std::string NAMESPACE_1("namespace_1");

/// A generic namespace string for tests.
static const std::string NAMESPACE_2("namespace_2");

/// A generic name string for tests.
static const std::string NAME_0("name_0");

/// A generic name string for tests.
static const std::string NAME_1("name_1");

/// A generic name string for tests.
static const std::string NAME_2("name_2");

/// A generic 'any name' string for tests.
static const std::string NAME_ANY("*");

static const std::string TEST_ATTACHMENT_CONTEXT_ID("TEST_ATTACHMENT_CONTEXT_ID");

/// Namespace and name combination for tests.
#define NAMESPACE_AND_NAME_0_0 NAMESPACE_0, NAME_0

/// Namespace and name combination (changing name this time) for tests.
#define NAMESPACE_AND_NAME_0_1 NAMESPACE_0, NAME_1

/// Namespace and name combination (changing name this time) for tests.
#define NAMESPACE_AND_NAME_0_2 NAMESPACE_0, NAME_2

/// Namespace and name combination ('any name' this time) for tests.
#define NAMESPACE_AND_NAME_0_ANY NAMESPACE_0, NAME_ANY

/// Namespace and name combination (changing namespace this time) for tests.
#define NAMESPACE_AND_NAME_1_0 NAMESPACE_1, NAME_0

/// Namespace and name combination (changing namespace this time) for tests.
#define NAMESPACE_AND_NAME_2_0 NAMESPACE_2, NAME_0

/// Namespace and name combination (changing namespace this time) for tests.
#define NAMESPACE_AND_NAME_2_ANY NAMESPACE_2, NAME_ANY

/// Long timeout we only reach when a concurrency test fails.
static const std::chrono::seconds LONG_TIMEOUT(15);

/// Represent a wildcard string.
static const std::string WILDCARD = "*";

/**
 * DirectiveRouterTest
 */
class DirectiveRouterTest : public ::testing::Test {
public:
    void SetUp() override;
    void TearDown() override;
    /**
     * Create a directive with the given attributes.
     *
     * @param endpointId The target endpointId.
     * @param instance The instance name.
     * @param nameSpace The directive name space.
     * @param name The directive name.
     * @return A pointer to a new directive.
     */
    std::shared_ptr<AVSDirective> createDirective(
        const std::string& endpointId,
        const utils::Optional<std::string>& instance,
        const std::string& nameSpace,
        const std::string& name) const;

    /// A DirectiveRouter instance to test with.
    DirectiveRouter m_router;

    /// AttachmentManager with which to create directives.
    std::shared_ptr<AttachmentManager> m_attachmentManager;

    /// Generic @c AVSDirective for tests.
    std::shared_ptr<AVSDirective> m_directive_0_0;

    /// Generic @c AVSDirective for tests.
    std::shared_ptr<AVSDirective> m_directive_0_1;

    /// Generic @c AVSDirective for tests.
    std::shared_ptr<AVSDirective> m_directive_0_2;

    /// Generic @c AVSDirective for tests.
    std::shared_ptr<AVSDirective> m_directive_1_0;

    /// Generic @c AVSDirective for tests.
    std::shared_ptr<AVSDirective> m_directive_2_0;
};

void DirectiveRouterTest::SetUp() {
    m_attachmentManager = std::make_shared<AttachmentManager>(AttachmentManager::AttachmentType::IN_PROCESS);

    auto avsMessageHeader_0_0 =
        std::make_shared<AVSMessageHeader>(NAMESPACE_AND_NAME_0_0, MESSAGE_ID_0_0, DIALOG_REQUEST_ID_0);
    m_directive_0_0 = AVSDirective::create(
        UNPARSED_DIRECTIVE, avsMessageHeader_0_0, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID);
    auto avsMessageHeader_0_1 =
        std::make_shared<AVSMessageHeader>(NAMESPACE_AND_NAME_0_1, MESSAGE_ID_0_1, DIALOG_REQUEST_ID_0);
    m_directive_0_1 = AVSDirective::create(
        UNPARSED_DIRECTIVE, avsMessageHeader_0_1, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID);
    auto avsMessageHeader_0_2 =
        std::make_shared<AVSMessageHeader>(NAMESPACE_AND_NAME_0_2, MESSAGE_ID_0_2, DIALOG_REQUEST_ID_0);
    m_directive_0_2 = AVSDirective::create(
        UNPARSED_DIRECTIVE, avsMessageHeader_0_2, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID);
    auto avsMessageHeader_1_0 =
        std::make_shared<AVSMessageHeader>(NAMESPACE_AND_NAME_1_0, MESSAGE_ID_1_0, DIALOG_REQUEST_ID_0);
    m_directive_1_0 = AVSDirective::create(
        UNPARSED_DIRECTIVE, avsMessageHeader_1_0, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID);
    auto avsMessageHeader_2_0 =
        std::make_shared<AVSMessageHeader>(NAMESPACE_AND_NAME_2_0, MESSAGE_ID_2_0, DIALOG_REQUEST_ID_0);
    m_directive_2_0 = AVSDirective::create(
        UNPARSED_DIRECTIVE, avsMessageHeader_2_0, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID);
}

void DirectiveRouterTest::TearDown() {
    m_router.shutdown();
}

std::shared_ptr<AVSDirective> DirectiveRouterTest::createDirective(
    const std::string& endpointId,
    const utils::Optional<std::string>& instance,
    const std::string& nameSpace,
    const std::string& name) const {
    auto header = std::make_shared<AVSMessageHeader>(
        nameSpace, name, "messageId", "dialogId", "token", "eventToken", "3.0", instance.valueOr(""));
    AVSMessageEndpoint endpoint{endpointId};
    return AVSDirective::create(
        UNPARSED_DIRECTIVE, header, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID, endpoint);
}

/**
 * Check that an un-registered @c AVDirective will not be routed.
 */
TEST_F(DirectiveRouterTest, test_unroutedDirective) {
    ASSERT_FALSE(m_router.handleDirectiveImmediately(m_directive_0_0));
}

/**
 * Register an @c AVSDirective for routing. Exercise routing via @c handleDirectiveImmediately().
 * Expect that the @c AVSDirective is routed.
 */
TEST_F(DirectiveRouterTest, test_settingADirectiveHandler) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false);
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);
    ASSERT_TRUE(m_router.addDirectiveHandler(handler0));

    EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(m_directive_0_0)).Times(1);
    EXPECT_CALL(*(handler0.get()), preHandleDirective(_, _)).Times(0);
    EXPECT_CALL(*(handler0.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), onDeregistered()).Times(1);

    ASSERT_TRUE(m_router.handleDirectiveImmediately(m_directive_0_0));
}

/**
 * Register @c AVSDirectives to be routed to different handlers. Exercise routing via @c preHandleDirective().
 * Expect that the @c AVSDirectives make it to their registered handler.
 */
TEST_F(DirectiveRouterTest, test_registeringMultipeHandler) {
    DirectiveHandlerConfiguration handler0Config;
    auto audioNonBlockingPolicy = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false);
    handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);

    DirectiveHandlerConfiguration handler1Config;
    handler1Config[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler1 = MockDirectiveHandler::create(handler1Config);

    DirectiveHandlerConfiguration handler2Config;
    handler2Config[NamespaceAndName{NAMESPACE_AND_NAME_0_ANY}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler2 = MockDirectiveHandler::create(handler2Config);

    DirectiveHandlerConfiguration handler3Config;
    handler3Config[NamespaceAndName{NAMESPACE_AND_NAME_1_0}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler3 = MockDirectiveHandler::create(handler3Config);

    DirectiveHandlerConfiguration handler4Config;
    handler4Config[NamespaceAndName{NAMESPACE_AND_NAME_2_ANY}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler4 = MockDirectiveHandler::create(handler4Config);

    ASSERT_TRUE(m_router.addDirectiveHandler(handler0));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler1));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler2));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler3));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler4));

    EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), preHandleDirective(m_directive_0_0, _)).Times(1);
    EXPECT_CALL(*(handler0.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), onDeregistered()).Times(1);

    EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler1.get()), preHandleDirective(m_directive_0_1, _)).Times(1);
    EXPECT_CALL(*(handler1.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler1.get()), onDeregistered()).Times(1);

    // Test that wildcard handler2 will get a directive, while other handlers exist within the same namespace
    EXPECT_CALL(*(handler2.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler2.get()), preHandleDirective(m_directive_0_2, _)).Times(1);
    EXPECT_CALL(*(handler2.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler2.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler2.get()), onDeregistered()).Times(1);

    EXPECT_CALL(*(handler3.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler3.get()), preHandleDirective(m_directive_1_0, _)).Times(1);
    EXPECT_CALL(*(handler3.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler3.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler3.get()), onDeregistered()).Times(1);

    // Test that wildcard handler4 will get a directive, when no other handlers exist within the same namespace
    EXPECT_CALL(*(handler4.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler4.get()), preHandleDirective(m_directive_2_0, _)).Times(1);
    EXPECT_CALL(*(handler4.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler4.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler4.get()), onDeregistered()).Times(1);

    ASSERT_TRUE(m_router.preHandleDirective(m_directive_0_0, nullptr));
    ASSERT_TRUE(m_router.preHandleDirective(m_directive_0_1, nullptr));
    ASSERT_TRUE(m_router.preHandleDirective(m_directive_0_2, nullptr));
    ASSERT_TRUE(m_router.preHandleDirective(m_directive_1_0, nullptr));
    ASSERT_TRUE(m_router.preHandleDirective(m_directive_2_0, nullptr));
}

/**
 * Register @c AVSDirectives to be routed to different handlers. Then update the registration by clearing it and
 * replacing it with a new configuration where one of the handlers is removed, one is changed, and one is not changed.
 * Exercise routing via @c handleDirective(). Expect that the @c AVSDirectives are delivered to the last handler they
 * were last assigned to and that false and a @c BlockingPolicy of NONE is returned for the directive whose handler
 * was removed.
 */
TEST_F(DirectiveRouterTest, test_removingChangingAndNotChangingHandlers) {
    DirectiveHandlerConfiguration handler0Config;
    auto audioBlockingPolicy = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    auto audioNonBlockingPolicy = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false);
    handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);

    DirectiveHandlerConfiguration handler1Config;
    handler1Config[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler1 = MockDirectiveHandler::create(handler1Config);

    DirectiveHandlerConfiguration handler2Config;
    handler2Config[NamespaceAndName{NAMESPACE_AND_NAME_1_0}] = audioNonBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler2 = MockDirectiveHandler::create(handler2Config);

    DirectiveHandlerConfiguration handler3Config;
    handler3Config[NamespaceAndName{NAMESPACE_AND_NAME_1_0}] = audioBlockingPolicy;
    std::shared_ptr<MockDirectiveHandler> handler3 = MockDirectiveHandler::create(handler3Config);

    EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), preHandleDirective(_, _)).Times(0);
    EXPECT_CALL(*(handler0.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), onDeregistered()).Times(1);

    EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler1.get()), preHandleDirective(_, _)).Times(0);
    EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_0_1)).WillOnce(Return(true));
    EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler1.get()), onDeregistered()).Times(2);

    EXPECT_CALL(*(handler2.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler2.get()), preHandleDirective(_, _)).Times(0);
    EXPECT_CALL(*(handler2.get()), handleDirective(_)).Times(0);
    EXPECT_CALL(*(handler2.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler2.get()), onDeregistered()).Times(1);

    EXPECT_CALL(*(handler3.get()), handleDirective(MESSAGE_ID_1_0)).WillOnce(Return(true));

    ASSERT_TRUE(m_router.addDirectiveHandler(handler0));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler1));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler2));

    ASSERT_TRUE(m_router.removeDirectiveHandler(handler0));
    ASSERT_TRUE(m_router.removeDirectiveHandler(handler1));
    ASSERT_TRUE(m_router.removeDirectiveHandler(handler2));

    ASSERT_FALSE(m_router.removeDirectiveHandler(handler0));
    ASSERT_FALSE(m_router.removeDirectiveHandler(handler1));
    ASSERT_FALSE(m_router.removeDirectiveHandler(handler2));

    ASSERT_TRUE(m_router.addDirectiveHandler(handler1));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler3));

    auto policy = m_router.getPolicy(m_directive_0_0);
    ASSERT_FALSE(m_router.handleDirective(m_directive_0_0));
    ASSERT_FALSE(policy.isValid());
    policy = m_router.getPolicy(m_directive_0_1);
    ASSERT_TRUE(m_router.handleDirective(m_directive_0_1));
    ASSERT_EQ(policy, audioNonBlockingPolicy);
    policy = m_router.getPolicy(m_directive_1_0);
    ASSERT_TRUE(m_router.handleDirective(m_directive_1_0));
    ASSERT_EQ(policy, audioBlockingPolicy);
}

/**
 * Register two @c AVSDirectives to be routed to different handlers with different blocking policies. Configure the
 * mock handlers to return false from @c handleDirective(). Exercise routing via handleDirective(). Expect that
 * @c DirectiveRouter::handleDirective() returns @c false and BlockingPolicy::nonePolicy() to indicate failure.
 */
TEST_F(DirectiveRouterTest, test_resultOfHandleDirectiveFailure) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false);
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);

    DirectiveHandlerConfiguration handler1Config;
    handler1Config[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler1 = MockDirectiveHandler::create(handler1Config);

    ASSERT_TRUE(m_router.addDirectiveHandler(handler0));
    ASSERT_TRUE(m_router.addDirectiveHandler(handler1));

    EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), preHandleDirective(_, _)).Times(0);
    EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0_0)).WillOnce(Return(false));
    EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), onDeregistered()).Times(1);

    EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler1.get()), preHandleDirective(_, _)).Times(0);
    EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_0_1)).WillOnce(Return(false));
    EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler1.get()), onDeregistered()).Times(1);

    ASSERT_FALSE(m_router.handleDirective(m_directive_0_0));
    ASSERT_FALSE(m_router.handleDirective(m_directive_0_1));
}

/**
 * Register an @c AVSDirective for handling.  Invoke preHandleDirective() on a new thread and block its return
 * until a subsequent invocation of @c handleDirective() has started. Expect the blocked call to preHandleDirective()
 * to complete quickly.
 */
TEST_F(DirectiveRouterTest, test_handlerMethodsCanRunConcurrently) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);

    ASSERT_TRUE(m_router.addDirectiveHandler(handler0));

    std::promise<void> waker;
    auto sleeper = waker.get_future();

    auto sleeperFunction = [&sleeper]() {
        ASSERT_EQ(sleeper.wait_for(LONG_TIMEOUT), std::future_status::ready)
            << "ERROR: Timeout reached while waiting for concurrent handler.";
    };

    auto wakerFunction = [&waker]() {
        waker.set_value();
        return true;
    };

    EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), preHandleDirective(m_directive_0_0, _)).WillOnce(InvokeWithoutArgs(sleeperFunction));
    EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0_0)).WillOnce(InvokeWithoutArgs(wakerFunction));
    EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0);
    EXPECT_CALL(*(handler0.get()), onDeregistered()).Times(1);

    std::thread sleeperThread([this]() { ASSERT_TRUE(m_router.preHandleDirective(m_directive_0_0, nullptr)); });
    ASSERT_TRUE(m_router.handleDirective(m_directive_0_0));
    auto policy = m_router.getPolicy(m_directive_0_0);
    ASSERT_EQ(policy, BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true));
    sleeperThread.join();
}

/**
 * Check that we are able to match directives to handlers that use a per directive routing rule.
 */
TEST_F(DirectiveRouterTest, test_perDirectiveRuleMatching) {
    // Configure handler.
    auto rule = routingRulePerDirective("endpointId", std::string("instance"), "namespace", "name");
    DirectiveHandlerConfiguration handlerConfig;
    handlerConfig[rule] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler = MockDirectiveHandler::create(handlerConfig);
    ASSERT_TRUE(m_router.addDirectiveHandler(handler));

    // Add expectations.
    auto directive = createDirective(rule.endpointId, rule.instance, rule.nameSpace, rule.name);
    EXPECT_CALL(*handler, handleDirectiveImmediately(directive)).Times(1);
    EXPECT_CALL(*handler, onDeregistered()).Times(1);

    // Handle the directive.
    EXPECT_TRUE(m_router.handleDirectiveImmediately(directive));
}

/**
 * Check that we are able to match directives to handlers that use a per name space routing rule.
 */
TEST_F(DirectiveRouterTest, test_perNamespaceRuleMatching) {
    // Configure handler.
    auto rule = routingRulePerNamespace("endpointId", std::string("instance"), "namespace");
    DirectiveHandlerConfiguration handlerConfig;
    handlerConfig[rule] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler = MockDirectiveHandler::create(handlerConfig);
    ASSERT_TRUE(m_router.addDirectiveHandler(handler));

    // Use a random name for the directive.
    const std::string directiveName = "RandomName";
    EXPECT_NE(rule.name, directiveName);

    // Add expectations.
    auto directive = createDirective(rule.endpointId, rule.instance, rule.nameSpace, directiveName);
    EXPECT_CALL(*handler, handleDirectiveImmediately(directive)).Times(1);
    EXPECT_CALL(*handler, onDeregistered()).Times(1);

    // Handle the directive.
    EXPECT_TRUE(m_router.handleDirectiveImmediately(directive));
}

/**
 * Check that we are able to match directives to handlers that use a per instance routing rule.
 */
TEST_F(DirectiveRouterTest, test_perInstanceRuleMatching) {
    // Configure handler.
    auto rule = routingRulePerInstance("endpointId", std::string("instance"));
    DirectiveHandlerConfiguration handlerConfig;
    handlerConfig[rule] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler = MockDirectiveHandler::create(handlerConfig);
    ASSERT_TRUE(m_router.addDirectiveHandler(handler));

    // Use a random name / name space for the directive.
    const std::string directiveName = "RandomName";
    const std::string directiveNameSpace = "RandomNamespace";
    EXPECT_NE(rule.name, directiveName);
    EXPECT_NE(rule.nameSpace, directiveNameSpace);

    // Add expectations.
    auto directive = createDirective(rule.endpointId, rule.instance, directiveNameSpace, directiveName);
    EXPECT_CALL(*handler, handleDirectiveImmediately(directive)).Times(1);
    EXPECT_CALL(*handler, onDeregistered()).Times(1);

    // Handle the directive.
    EXPECT_TRUE(m_router.handleDirectiveImmediately(directive));
}

/**
 * Check that we are able to match directives to handlers that use a per name space with any instance routing rule.
 */
TEST_F(DirectiveRouterTest, test_perNamespaceAnyInstanceRuleMatching) {
    // Configure handler.
    auto rule = routingRulePerNamespaceAnyInstance("endpointId", "nameSpace");
    DirectiveHandlerConfiguration handlerConfig;
    handlerConfig[rule] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler = MockDirectiveHandler::create(handlerConfig);
    ASSERT_TRUE(m_router.addDirectiveHandler(handler));

    // Use a random name / instance for the directive.
    const std::string directiveName = "RandomName";
    const std::string directiveInstance = "RandomInstance";
    EXPECT_NE(rule.name, directiveName);
    EXPECT_NE(rule.instance.valueOr(""), directiveInstance);

    // Add expectations.
    auto directive = createDirective(rule.endpointId, directiveInstance, rule.nameSpace, directiveName);
    EXPECT_CALL(*handler, handleDirectiveImmediately(directive)).Times(1);
    EXPECT_CALL(*handler, onDeregistered()).Times(1);

    // Handle the directive.
    EXPECT_TRUE(m_router.handleDirectiveImmediately(directive));
}

/**
 * Check that we are able to match directives to handlers that use a per endpoint routing rule.
 */
TEST_F(DirectiveRouterTest, test_perEndpointMatching) {
    // Configure handler.
    auto rule = routingRulePerEndpoint("endpoint");
    DirectiveHandlerConfiguration handlerConfig;
    handlerConfig[rule] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler = MockDirectiveHandler::create(handlerConfig);
    ASSERT_TRUE(m_router.addDirectiveHandler(handler));

    // Use a random name, name space, and instance for the directive.
    const std::string directiveName = "RandomName";
    const std::string directiveNameSpace = "RandomNamespace";
    const std::string directiveInstance = "RandomInstance";
    EXPECT_NE(rule.name, directiveName);
    EXPECT_NE(rule.nameSpace, directiveNameSpace);
    EXPECT_NE(rule.instance.valueOr(""), directiveInstance);

    // Add expectations.
    auto directive = createDirective(rule.endpointId, directiveInstance, directiveNameSpace, directiveName);
    EXPECT_CALL(*handler, handleDirectiveImmediately(directive)).Times(1);
    EXPECT_CALL(*handler, onDeregistered()).Times(1);

    // Handle the directive.
    EXPECT_TRUE(m_router.handleDirectiveImmediately(directive));
}

/**
 * Check that we fail when a directive handler declares an invalid routing rule.
 */
TEST_F(DirectiveRouterTest, test_addDirectiveHandlerWithInvalidRoutingRuleShouldFail) {
    // Configure handler with endpoint wildcard.
    auto rule = routingRulePerEndpoint(WILDCARD);
    DirectiveHandlerConfiguration handlerConfig;
    handlerConfig[rule] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true);
    std::shared_ptr<MockDirectiveHandler> handler = MockDirectiveHandler::create(handlerConfig);
    EXPECT_FALSE(m_router.addDirectiveHandler(handler));
}

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