avs-device-sdk/ADSL/test/DirectiveRouterTest.cpp

/*
 * Copyright 2017-2018 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;

/// 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);

/**
 * DirectiveRouterTest
 */
class DirectiveRouterTest : public ::testing::Test {
public:
    void SetUp() override;
    void TearDown() override;

    /// 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();
}

/**
 * Check that an un-registered @c AVDirective will not be routed.
 */
TEST_F(DirectiveRouterTest, testUnroutedDirective) {
    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, testSettingADirectiveHandler) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy::NON_BLOCKING;
    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, testRegisteringMultipeHandler) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy::NON_BLOCKING;
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);

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

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

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

    DirectiveHandlerConfiguration handler4Config;
    handler4Config[{NAMESPACE_AND_NAME_2_ANY}] = BlockingPolicy::NON_BLOCKING;
    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, testRemovingChangingAndNotChangingHandlers) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy::NON_BLOCKING;
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);

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

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

    DirectiveHandlerConfiguration handler3Config;
    handler3Config[{NAMESPACE_AND_NAME_1_0}] = BlockingPolicy::BLOCKING;
    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 = BlockingPolicy::NONE;
    ASSERT_FALSE(m_router.handleDirective(m_directive_0_0, &policy));
    ASSERT_EQ(policy, BlockingPolicy::NONE);
    ASSERT_TRUE(m_router.handleDirective(m_directive_0_1, &policy));
    ASSERT_EQ(policy, BlockingPolicy::NON_BLOCKING);
    ASSERT_TRUE(m_router.handleDirective(m_directive_1_0, &policy));
    ASSERT_EQ(policy, BlockingPolicy::BLOCKING);
}

/**
 * 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::NONE to indicate failure.
 */
TEST_F(DirectiveRouterTest, testResultOfHandleDirectiveFailure) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy::NON_BLOCKING;
    std::shared_ptr<MockDirectiveHandler> handler0 = MockDirectiveHandler::create(handler0Config);

    DirectiveHandlerConfiguration handler1Config;
    handler1Config[{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy::BLOCKING;
    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);

    auto policy = BlockingPolicy::NONE;
    ASSERT_FALSE(m_router.handleDirective(m_directive_0_0, &policy));
    ASSERT_EQ(policy, BlockingPolicy::NONE);
    ASSERT_FALSE(m_router.handleDirective(m_directive_0_1, &policy));
    ASSERT_EQ(policy, BlockingPolicy::NONE);
}

/**
 * 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, testHandlerMethodsCanRunConcurrently) {
    DirectiveHandlerConfiguration handler0Config;
    handler0Config[{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy::BLOCKING;
    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)); });
    auto policy = BlockingPolicy::NONE;
    ASSERT_TRUE(m_router.handleDirective(m_directive_0_0, &policy));
    ASSERT_EQ(policy, BlockingPolicy::BLOCKING);
    sleeperThread.join();
}

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