avs-device-sdk/CapabilityAgents/Alexa/test/AlexaInterfaceCapabilityAgentTest.cpp

/*
 * 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 <future>
#include <memory>
#include <gmock/gmock.h>

#include <Alexa/AlexaEventProcessedNotifier.h>
#include <Alexa/AlexaInterfaceCapabilityAgent.h>
#include <Alexa/AlexaInterfaceConstants.h>
#include <Alexa/AlexaInterfaceMessageSenderInternalInterface.h>
#include <AVSCommon/AVS/AVSDirective.h>
#include <AVSCommon/AVS/NamespaceAndName.h>
#include <AVSCommon/SDKInterfaces/AlexaEventProcessedObserverInterface.h>
#include <AVSCommon/SDKInterfaces/MockAlexaInterfaceMessageSender.h>
#include <AVSCommon/SDKInterfaces/MockDirectiveHandlerResult.h>
#include <AVSCommon/SDKInterfaces/MockExceptionEncounteredSender.h>
#include <AVSCommon/SDKInterfaces/Endpoints/DefaultEndpointAnnotation.h>
#include <AVSCommon/SDKInterfaces/Endpoints/MockEndpointCapabilitiesRegistrar.h>
#include <AVSCommon/Utils/Memory/Memory.h>

namespace alexaClientSDK {
namespace capabilityAgents {
namespace alexa {
namespace test {

using namespace acsdkManufactory;
using namespace avsCommon::avs;
using namespace avsCommon::sdkInterfaces::test;
using namespace avsCommon::sdkInterfaces::endpoints;
using namespace avsCommon::sdkInterfaces::endpoints::test;
using namespace avsCommon::utils::memory;

using namespace ::testing;

using ::testing::Matcher;

using DefaultEndpointAnnotation = avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation;

/// The namespace for this capability agent.
static const std::string NAMESPACE = "Alexa";

/// The Alexa.EventProcessed directive name.
static const std::string EVENT_PROCESSED_DIRECTIVE_NAME = "EventProcessed";

/// The Alexa.ReportState directive name.
static const std::string REPORT_STATE_DIRECTIVE_NAME = "ReportState";

/// The @c EventProcessed directive signature.
static const NamespaceAndName EVENT_PROCESSED{NAMESPACE, EVENT_PROCESSED_DIRECTIVE_NAME};

/// The @c ReportState directive signature.
static const NamespaceAndName REPORT_STATE{NAMESPACE, REPORT_STATE_DIRECTIVE_NAME};

/// The @c test messageId.
static const std::string TEST_ENDPOINT_ID = "test-endpoint";

/// The @c test messageId.
static const std::string TEST_MESSAGE_ID = "abcdefg";

/// The @c test EventCorrelationToken.
static const std::string TEST_EVENTCORRELATION_TOKEN = "abcdefg";

// clang-format off
/// A sample Directive JSON string for the purposes of creating an AVSDirective object.
static const std::string VALID_EVENT_PROCESSED_DIRECTIVE =
    "{"
        "\"directive\":{"
            "\"header\":{"
                "\"namespace\":\""+NAMESPACE+"\","
                "\"name\":\""+EVENT_PROCESSED.name+"\","
                "\"messageId\":\""+TEST_MESSAGE_ID+"\","
                "\"eventCorrelationToken\":\""+TEST_EVENTCORRELATION_TOKEN+"\""
            "},"
            "\"payload\":{}"
        "}"
    "}";

/// A directive with an incorrect name.
static const std::string UNKNOWN_DIRECTIVE =
    "{"
        "\"directive\":{"
            "\"header\":{"
                "\"namespace\":\""+NAMESPACE+"\","
                "\"name\":\"UnknownDirective\","
                "\"messageId\":\""+TEST_MESSAGE_ID+"\","
                "\"eventCorrelationToken\":\""+TEST_EVENTCORRELATION_TOKEN+"\""
            "},"
            "\"payload\":{}"
        "}"
    "}";

/// An invalid @c EventProcessed Directive with no eventCorrelationToken
static const std::string EVENT_PROCESSED_WITH_NO_EVENT_CORRELATION_TOKEN =
    "{"
        "\"directive\":{"
            "\"header\":{"
                "\"namespace\":\""+NAMESPACE+"\","
                "\"name\":\""+EVENT_PROCESSED.name+"\","
                "\"messageId\":\""+TEST_MESSAGE_ID+"\""
            "},"
            "\"payload\":{}"
        "}"
    "}";

/// A sample Directive JSON string for the purposes of creating an AVSDirective object.
static const std::string VALID_ALEXA_REPORTSTATE_DIRECTIVE =
    "{"
        "\"directive\":{"
            "\"header\":{"
                "\"namespace\":\""+NAMESPACE+"\","
                "\"name\":\""+REPORT_STATE.name+"\","
                "\"messageId\":\""+TEST_MESSAGE_ID+"\","
                "\"correlationToken\":\""+TEST_EVENTCORRELATION_TOKEN+"\""
            "},"
            "\"endpoint\":{"
                "\"endpointId\":\""+TEST_ENDPOINT_ID+"\""
            "},"
            "\"payload\":{}"
        "}"
    "}";

/// A sample Directive JSON string for the purposes of creating an AVSDirective object.
static const std::string INVALID_ALEXA_REPORTSTATE_DIRECTIVE_NO_ENDPOINT =
    "{"
        "\"directive\":{"
            "\"header\":{"
                "\"namespace\":\""+NAMESPACE+"\","
                "\"name\":\""+REPORT_STATE.name+"\","
                "\"messageId\":\""+TEST_MESSAGE_ID+"\","
                "\"correlationToken\":\""+TEST_EVENTCORRELATION_TOKEN+"\""
            "},"
            "\"payload\":{}"
        "}"
    "}";
// clang-format on

/// Timeout when waiting for future to be set.
static std::chrono::milliseconds TIMEOUT(1000);

/// A test @c EventProcessedObserver.
class TestEventProcessedObserver : public avsCommon::sdkInterfaces::AlexaEventProcessedObserverInterface {
public:
    bool waitForEventProcessed(const std::string& eventCorrelationToken) {
        std::unique_lock<std::mutex> lock{m_mutex};
        auto predicate = [this, eventCorrelationToken] { return m_eventCorrelationToken == eventCorrelationToken; };
        return m_wakeTrigger.wait_for(lock, TIMEOUT, predicate);
    }

    void onAlexaEventProcessedReceived(const std::string& eventCorrelationToken) {
        std::lock_guard<std::mutex> lock{m_mutex};
        m_eventCorrelationToken = eventCorrelationToken;
        m_wakeTrigger.notify_one();
    }

private:
    std::mutex m_mutex;
    std::condition_variable m_wakeTrigger;
    std::string m_eventCorrelationToken;
};

/// A mock @c MockAlexaInterfaceMessageSenderInternal

class MockAlexaInterfaceMessageSenderInternal : public AlexaInterfaceMessageSenderInternalInterface {
public:
    MOCK_METHOD3(
        sendStateReportEvent,
        bool(
            const std::string& instance,
            const std::string& correlationToken,
            const avsCommon::avs::AVSMessageEndpoint& endpoint));
    MOCK_METHOD4(
        sendResponseEvent,
        bool(
            const std::string& instance,
            const std::string& correlationToken,
            const avsCommon::avs::AVSMessageEndpoint& endpoint,
            const std::string& jsonPayload));
    MOCK_METHOD6(
        sendResponseEvent,
        bool(
            const std::string& instance,
            const std::string& correlationToken,
            const avsCommon::avs::AVSMessageEndpoint& endpoint,
            const std::string& responseNamespace,
            const std::string& responseName,
            const std::string& jsonPayload));
    MOCK_METHOD5(
        sendErrorResponseEvent,
        bool(
            const std::string& instance,
            const std::string& correlationToken,
            const avsCommon::avs::AVSMessageEndpoint& endpoint,
            const ErrorResponseType errorType,
            const std::string& errorMessage));
    MOCK_METHOD5(
        sendErrorResponseEvent,
        bool(
            const std::string& instance,
            const std::string& correlationToken,
            const avsCommon::avs::AVSMessageEndpoint& endpoint,
            const std::string& responseNamespace,
            const std::string& payload));
    MOCK_METHOD3(
        sendDeferredResponseEvent,
        bool(const std::string& instance, const std::string& correlationToken, const int estimatedDeferralInSeconds));
    MOCK_METHOD1(
        alexaResponseTypeToErrorType,
        ErrorResponseType(const avsCommon::avs::AlexaResponseType& responseType));
};

/**
 * Test harness for @c EventProcessedHandler class.
 */
class AlexaInterfaceCapabilityAgentTest : public Test {
public:
    /// Setup the test harness for running a test.
    void SetUp() override;

    /// Clean up the test harness for running a test.
    void TearDown() override;

    /// Function to set the promise and wake @ m_wakeSetCompleteFuture.
    void wakeOnSetCompleted();

    /**
     * Constructor.
     */
    AlexaInterfaceCapabilityAgentTest() :
            m_wakeSetCompletedPromise{},
            m_wakeSetCompletedFuture{m_wakeSetCompletedPromise.get_future()} {
    }

protected:
    /// Promise to synchronize directive handling through setCompleted.
    std::promise<void> m_wakeSetCompletedPromise;

    /// Future to synchronize directive handling through setCompleted.
    std::future<void> m_wakeSetCompletedFuture;

    /// A strict mock that allows the test to strictly monitor the handling of directives.
    std::unique_ptr<StrictMock<MockDirectiveHandlerResult>> m_mockDirectiveHandlerResult;

    /// Device info object to pass to the CA.
    std::shared_ptr<avsCommon::utils::DeviceInfo> m_deviceInfo;

    /// A strict mock that allows the test to strictly monitor the exceptions being sent.
    std::shared_ptr<StrictMock<MockExceptionEncounteredSender>> m_mockExceptionSender;

    /// A mock that allows the test to monitor calls to @c MockAlexaInterfaceMessageSenderInternal.
    std::shared_ptr<MockAlexaInterfaceMessageSenderInternal> m_mockAlexaMessageSender;

    /// A pointer to an instance of @c AlexaInterfaceCapabilityAgent that will be instantiated per test.
    std::shared_ptr<AlexaInterfaceCapabilityAgent> m_alexaInterfaceCapabilityAgent;
};

void AlexaInterfaceCapabilityAgentTest::SetUp() {
    m_deviceInfo = avsCommon::utils::DeviceInfo::create(
        "testClientId",
        "testProductId",
        "testSerialNumber",
        "testManufacturer",
        "testDescription",
        "testFriendlyName",
        "testDeviceType");
    m_mockExceptionSender = std::make_shared<StrictMock<MockExceptionEncounteredSender>>();
    m_mockDirectiveHandlerResult = make_unique<StrictMock<MockDirectiveHandlerResult>>();
    m_mockAlexaMessageSender = std::make_shared<MockAlexaInterfaceMessageSenderInternal>();

    m_alexaInterfaceCapabilityAgent = AlexaInterfaceCapabilityAgent::create(
        *m_deviceInfo, TEST_ENDPOINT_ID, m_mockExceptionSender, m_mockAlexaMessageSender);

    ASSERT_NE(m_alexaInterfaceCapabilityAgent, nullptr);
}

void AlexaInterfaceCapabilityAgentTest::TearDown() {
}

void AlexaInterfaceCapabilityAgentTest::wakeOnSetCompleted() {
    m_wakeSetCompletedPromise.set_value();
}

/**
 * Tests if create method returns null with null @c ExceptionSender and null @c ReportStateHandler.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, createWithInvalidParameters) {
    auto alexaInterfaceCA =
        AlexaInterfaceCapabilityAgent::create(*m_deviceInfo, TEST_ENDPOINT_ID, nullptr, m_mockAlexaMessageSender);
    ASSERT_EQ(alexaInterfaceCA, nullptr);

    alexaInterfaceCA =
        AlexaInterfaceCapabilityAgent::create(*m_deviceInfo, TEST_ENDPOINT_ID, m_mockExceptionSender, nullptr);
    ASSERT_EQ(alexaInterfaceCA, nullptr);
}

/**
 * Tests if Alexa.EventProcessed and Alexa.ReportState are present on the default endpoint config.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testDefaultEndpoint) {
    auto endpointId = m_deviceInfo->getDefaultEndpointId();
    auto alexaInterfaceCA = AlexaInterfaceCapabilityAgent::create(
        *m_deviceInfo, endpointId, m_mockExceptionSender, m_mockAlexaMessageSender);
    ASSERT_NE(alexaInterfaceCA, nullptr);

    auto configuration = alexaInterfaceCA->getConfiguration();
    EXPECT_NE(configuration.find(EVENT_PROCESSED), configuration.end());
    EXPECT_NE(configuration.find({NAMESPACE, REPORT_STATE_DIRECTIVE_NAME, endpointId}), configuration.end());
}

/**
 * Tests if Alexa.ReportState is present and Alexa.EventProcessed is NOT present on a non-default endpoint config.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testNonDefaultEndpoint) {
    auto endpointId = TEST_ENDPOINT_ID;
    auto alexaInterfaceCA = AlexaInterfaceCapabilityAgent::create(
        *m_deviceInfo, endpointId, m_mockExceptionSender, m_mockAlexaMessageSender);
    ASSERT_NE(alexaInterfaceCA, nullptr);

    auto configuration = alexaInterfaceCA->getConfiguration();
    EXPECT_EQ(configuration.find(EVENT_PROCESSED), configuration.end());
    EXPECT_NE(configuration.find({NAMESPACE, REPORT_STATE_DIRECTIVE_NAME, endpointId}), configuration.end());
}

/**
 * Tests if sendExceptionEncountered and setFailed are called for invalid directives.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testValidUnknownDirective) {
    auto directivePair = AVSDirective::create(UNKNOWN_DIRECTIVE, nullptr, "");
    std::shared_ptr<AVSDirective> directive = std::move(directivePair.first);
    ASSERT_THAT(directive, NotNull());

    EXPECT_CALL(*m_mockExceptionSender, sendExceptionEncountered(_, Eq(ExceptionErrorType::UNSUPPORTED_OPERATION), _));
    EXPECT_CALL(*m_mockDirectiveHandlerResult, setFailed(_))
        .WillOnce(InvokeWithoutArgs(this, &AlexaInterfaceCapabilityAgentTest::wakeOnSetCompleted));
    EXPECT_CALL(*m_mockAlexaMessageSender, sendStateReportEvent(_, _, _)).Times(Exactly(0));

    m_alexaInterfaceCapabilityAgent->CapabilityAgent::preHandleDirective(
        directive, std::move(m_mockDirectiveHandlerResult));
    m_alexaInterfaceCapabilityAgent->CapabilityAgent::handleDirective(directive->getMessageId());
    EXPECT_EQ(m_wakeSetCompletedFuture.wait_for(TIMEOUT), std::future_status::ready);
}

/**
 * Tests if sendExceptionEncountered and setFailed are called when eventCorrelationToken is not in the EventProcessed
 * directive.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testInvalidEventProcessedDirective) {
    auto directivePair = AVSDirective::create(EVENT_PROCESSED_WITH_NO_EVENT_CORRELATION_TOKEN, nullptr, "");
    std::shared_ptr<AVSDirective> directive = std::move(directivePair.first);
    ASSERT_THAT(directive, NotNull());

    EXPECT_CALL(
        *m_mockExceptionSender,
        sendExceptionEncountered(_, Eq(ExceptionErrorType::UNEXPECTED_INFORMATION_RECEIVED), _));
    EXPECT_CALL(*m_mockDirectiveHandlerResult, setFailed(_))
        .WillOnce(InvokeWithoutArgs(this, &AlexaInterfaceCapabilityAgentTest::wakeOnSetCompleted));
    EXPECT_CALL(*m_mockAlexaMessageSender, sendStateReportEvent(_, _, _)).Times(Exactly(0));

    m_alexaInterfaceCapabilityAgent->CapabilityAgent::preHandleDirective(
        directive, std::move(m_mockDirectiveHandlerResult));
    m_alexaInterfaceCapabilityAgent->CapabilityAgent::handleDirective(directive->getMessageId());
    EXPECT_EQ(m_wakeSetCompletedFuture.wait_for(TIMEOUT), std::future_status::ready);
}

/**
 * Tests if setHandlingCompleted is called and if the observers are notified when a valid EventProcessed directive is
 * received.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testValidEventProcessedDirective) {
    auto testNotifier = std::make_shared<AlexaEventProcessedNotifier>();
    auto testObserver = std::make_shared<TestEventProcessedObserver>();

    auto registrar = std::make_shared<MockEndpointCapabilitiesRegistrar>();
    auto annotatedRegistrar = Annotated<DefaultEndpointAnnotation, EndpointCapabilitiesRegistrarInterface>(registrar);
    EXPECT_CALL(
        *registrar,
        withCapability(CapabilityConfiguration(ALEXA_INTERFACE_TYPE, ALEXA_INTERFACE_NAME, ALEXA_INTERFACE_VERSION), _))
        .WillOnce(ReturnRef(*registrar));

    testNotifier->addObserver(testObserver);

    /// Only the default endpoint handles AlexaEventProcessed directives.
    m_alexaInterfaceCapabilityAgent = AlexaInterfaceCapabilityAgent::createDefaultAlexaInterfaceCapabilityAgent(
        m_deviceInfo, m_mockExceptionSender, m_mockAlexaMessageSender, testNotifier, annotatedRegistrar);

    auto directivePair = AVSDirective::create(VALID_EVENT_PROCESSED_DIRECTIVE, nullptr, "");
    std::shared_ptr<AVSDirective> directive = std::move(directivePair.first);
    ASSERT_THAT(directive, NotNull());

    EXPECT_CALL(*m_mockExceptionSender, sendExceptionEncountered(_, _, _)).Times(Exactly(0));
    EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted())
        .WillOnce(InvokeWithoutArgs(this, &AlexaInterfaceCapabilityAgentTest::wakeOnSetCompleted));
    EXPECT_CALL(*m_mockAlexaMessageSender, sendStateReportEvent(_, _, _)).Times(Exactly(0));

    m_alexaInterfaceCapabilityAgent->CapabilityAgent::preHandleDirective(
        directive, std::move(m_mockDirectiveHandlerResult));
    m_alexaInterfaceCapabilityAgent->CapabilityAgent::handleDirective(directive->getMessageId());
    EXPECT_EQ(m_wakeSetCompletedFuture.wait_for(TIMEOUT), std::future_status::ready);
    ASSERT_TRUE(testObserver->waitForEventProcessed(TEST_EVENTCORRELATION_TOKEN));
}

/**
 * Tests if @c sendStateReportEvent() and setHandlingCompleted are called for a valid ReportState directive.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testValidReportStateDirective) {
    auto directivePair = AVSDirective::create(VALID_ALEXA_REPORTSTATE_DIRECTIVE, nullptr, "");
    std::shared_ptr<AVSDirective> directive = std::move(directivePair.first);
    ASSERT_THAT(directive, NotNull());

    EXPECT_CALL(*m_mockExceptionSender, sendExceptionEncountered(_, _, _)).Times(Exactly(0));
    EXPECT_CALL(
        *m_mockAlexaMessageSender,
        sendErrorResponseEvent(
            _, _, _, Matcher<AlexaInterfaceMessageSenderInternalInterface::ErrorResponseType>(testing::_), _))
        .Times(Exactly(0));
    EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted())
        .WillOnce(InvokeWithoutArgs(this, &AlexaInterfaceCapabilityAgentTest::wakeOnSetCompleted));
    EXPECT_CALL(*m_mockAlexaMessageSender, sendStateReportEvent(_, _, _))
        .Times(Exactly(1))
        .WillOnce(Invoke([](const std::string& instance,
                            const std::string& correlationToken,
                            const avsCommon::avs::AVSMessageEndpoint& endpoint) {
            EXPECT_EQ(correlationToken, TEST_EVENTCORRELATION_TOKEN);
            EXPECT_EQ(endpoint.endpointId, TEST_ENDPOINT_ID);
            return true;
        }));

    m_alexaInterfaceCapabilityAgent->CapabilityAgent::preHandleDirective(
        directive, std::move(m_mockDirectiveHandlerResult));
    m_alexaInterfaceCapabilityAgent->CapabilityAgent::handleDirective(directive->getMessageId());
    EXPECT_EQ(m_wakeSetCompletedFuture.wait_for(TIMEOUT), std::future_status::ready);
}

/**
 * Tests if @c sendErrorResponse() and setHandlingCompleted are called for ReportState failure.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testValidReportStateDirectiveReportStateFailure) {
    auto directivePair = AVSDirective::create(VALID_ALEXA_REPORTSTATE_DIRECTIVE, nullptr, "");
    std::shared_ptr<AVSDirective> directive = std::move(directivePair.first);
    ASSERT_THAT(directive, NotNull());

    EXPECT_CALL(
        *m_mockAlexaMessageSender,
        sendErrorResponseEvent(
            _,
            _,
            _,
            Matcher<AlexaInterfaceMessageSenderInternalInterface::ErrorResponseType>(
                AlexaInterfaceMessageSenderInternalInterface::ErrorResponseType::INTERNAL_ERROR),
            _));
    EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted())
        .WillOnce(InvokeWithoutArgs(this, &AlexaInterfaceCapabilityAgentTest::wakeOnSetCompleted));
    EXPECT_CALL(*m_mockAlexaMessageSender, sendStateReportEvent(_, _, _)).WillOnce(Return(false));

    m_alexaInterfaceCapabilityAgent->CapabilityAgent::preHandleDirective(
        directive, std::move(m_mockDirectiveHandlerResult));
    m_alexaInterfaceCapabilityAgent->CapabilityAgent::handleDirective(directive->getMessageId());
    EXPECT_EQ(m_wakeSetCompletedFuture.wait_for(TIMEOUT), std::future_status::ready);
}

/**
 * Tests if @c sendErrorResponse() and setHandlingCompleted is called for a ReportState directive without an endpoint.
 */
TEST_F(AlexaInterfaceCapabilityAgentTest, testInvalidReportStateDirectiveNoEndpoint) {
    auto directivePair = AVSDirective::create(INVALID_ALEXA_REPORTSTATE_DIRECTIVE_NO_ENDPOINT, nullptr, "");
    std::shared_ptr<AVSDirective> directive = std::move(directivePair.first);
    ASSERT_THAT(directive, NotNull());

    EXPECT_CALL(
        *m_mockAlexaMessageSender,
        sendErrorResponseEvent(
            _,
            _,
            _,
            Matcher<AlexaInterfaceMessageSenderInternalInterface::ErrorResponseType>(
                AlexaInterfaceMessageSenderInternalInterface::ErrorResponseType::INVALID_DIRECTIVE),
            _));
    EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted())
        .WillOnce(InvokeWithoutArgs(this, &AlexaInterfaceCapabilityAgentTest::wakeOnSetCompleted));

    m_alexaInterfaceCapabilityAgent->CapabilityAgent::preHandleDirective(
        directive, std::move(m_mockDirectiveHandlerResult));
    m_alexaInterfaceCapabilityAgent->CapabilityAgent::handleDirective(directive->getMessageId());
    EXPECT_EQ(m_wakeSetCompletedFuture.wait_for(TIMEOUT), std::future_status::ready);
}

}  // namespace test
}  // namespace alexa
}  // namespace capabilityAgents
}  // namespace alexaClientSDK