avs
/
avs-device-sdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
avs-device-sdk/CapabilityAgents/ModeController/test/ModeControllerCapabilityAge...

682 lines
26 KiB
C++
Raw Blame History

/*
* 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 <gmock/gmock.h>
#include <gtest/gtest.h>
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/writer.h>
#include "ModeController/ModeControllerAttributeBuilder.h"
#include "ModeController/ModeControllerCapabilityAgent.h"
#include <AVSCommon/AVS/Attachment/MockAttachmentManager.h>
#include <AVSCommon/SDKInterfaces/MockContextManager.h>
#include <AVSCommon/SDKInterfaces/MockDirectiveHandlerResult.h>
#include <AVSCommon/SDKInterfaces/MockExceptionEncounteredSender.h>
#include <AVSCommon/SDKInterfaces/MockAlexaInterfaceMessageSender.h>
#include <AVSCommon/SDKInterfaces/ModeController/ModeControllerAttributes.h>
#include <AVSCommon/SDKInterfaces/ModeController/ModeControllerInterface.h>
#include <AVSCommon/Utils/Memory/Memory.h>
#include <AVSCommon/Utils/Timing/TimePoint.h>
#include <AVSCommon/Utils/WaitEvent.h>
namespace alexaClientSDK {
namespace capabilityAgents {
namespace modeController {
namespace test {
using namespace avsCommon::avs;
using namespace avsCommon::avs::attachment::test;
using namespace avsCommon::sdkInterfaces;
using namespace avsCommon::sdkInterfaces::modeController;
using namespace avsCommon::sdkInterfaces::test;
using namespace avsCommon::utils::memory;
using namespace rapidjson;
using namespace ::testing;
// For readability.
using EndpointIdentifier = endpoints::EndpointIdentifier;
/// Timeout when waiting for futures to be set.
static std::chrono::milliseconds TIMEOUT(1000);
/// The namespace for capability agent.
static const std::string NAMESPACE{"Alexa.ModeController"};
/// The supported version
static const std::string INTERFACE_VERSION{"3"};
/// The name for SetMode directive
static const std::string NAME_SETMODE{"SetMode"};
/// The name for AdjustMode directive
static const std::string NAME_ADJUSTMODE{"AdjustMode"};
/// The name for modeValue property
static const std::string MODE_PROPERTY_NAME{"mode"};
/// An unknown directive signature.
static const std::string UNKNOWN_DIRECTIVE{"Unknown"};
/// The test EndpointId
static const EndpointIdentifier TEST_ENDPOINT_ID("testEndpointId");
/// The test instance
static const EndpointIdentifier TEST_INSTANCE("testInstance");
/// Event key.
static const std::string EVENT("event");
/// Header key.
static const std::string HEADER("header");
/// MessageId key.
static const std::string MESSAGE_ID("messageId");
/// MessageId for testing.
static const std::string MESSAGE_ID_TEST("MessageId_Test");
/// Dialog request Id key.
static const std::string DIALOG_REQUEST_ID("dialogRequestId");
/// DialogRequestId for testing.
static const std::string DIALOG_REQUEST_ID_TEST("DialogRequestId_Test");
/// Correlation token key.
static const std::string CORRELATION_TOKEN("correlationToken");
/// Correlation token for testing.
static const std::string CORRELATION_TOKEN_TEST("CorrelationToken_Test");
/// Event correlation token key.
static const std::string EVENT_CORRELATION_TOKEN("eventCorrelationToken");
/// Event correlation for testing.
static const std::string EVENT_CORRELATION_TOKEN_TEST("EventCorrelationToken_Test");
/// Time of sample key
static const std::string TIME_OF_SAMPLE("timeOfSample");
/// Time of sample used for testing
static const std::string TIME_OF_SAMPLE_TEST("2017-02-03T16:20:50.523Z");
/// Mode for testing
static std::string MODE_OPEN = "open";
/// Mode for testing
static std::string MODE_CLOSED = "close";
/// Mode Delta for testing.
static int MODE_DELTA = 1;
/// SetModeValue payload for testing
// clang-format off
static const std::string SET_MODE_PAYLOAD_TEST = R"({
"mode":")" + MODE_OPEN + R"("
})";
// clang-format on
/// AdjustModeValue payload for testing
// clang-format off
static const std::string ADJUST_MODE_PAYLOAD_TEST = R"({
"modeDelta":1
})";
// clang-format on
class MockModeControllerInterface : public ModeControllerInterface {
public:
using ModeResult = std::pair<AlexaResponseType, std::string>;
using GetModeResult = std::pair<AlexaResponseType, avsCommon::utils::Optional<ModeState>>;
MOCK_METHOD0(getConfiguration, ModeControllerConfiguration());
MOCK_METHOD2(setMode, ModeResult(const std::string& mode, const AlexaStateChangeCauseType cause));
MOCK_METHOD2(adjustMode, ModeResult(const int modeDelta, const AlexaStateChangeCauseType cause));
MOCK_METHOD0(getMode, GetModeResult());
MOCK_METHOD1(addObserver, bool(std::shared_ptr<ModeControllerObserverInterface>));
MOCK_METHOD1(removeObserver, void(const std::shared_ptr<ModeControllerObserverInterface>&));
};
class ModeControllerCapabilityAgentTest : public ::testing::Test {
public:
/// SetUp before each test case.
void SetUp() override;
/// Constructor.
ModeControllerCapabilityAgentTest() {
}
/// build modeControllerAttributes
avsCommon::utils::Optional<avsCommon::sdkInterfaces::modeController::ModeControllerAttributes>
buildModeControllerAttribute(const avsCommon::avs::CapabilityResources& capabilityResources) {
auto modeControllerAttributeBuilder =
capabilityAgents::modeController::ModeControllerAttributeBuilder::create();
avsCommon::sdkInterfaces::modeController::ModeResources closeModeResource;
if (!closeModeResource.addFriendlyNameWithText("Close", "en-US")) {
return avsCommon::utils::Optional<avsCommon::sdkInterfaces::modeController::ModeControllerAttributes>();
}
avsCommon::sdkInterfaces::modeController::ModeResources openModeResource;
if (!openModeResource.addFriendlyNameWithText("Open", "en-US")) {
return avsCommon::utils::Optional<avsCommon::sdkInterfaces::modeController::ModeControllerAttributes>();
}
modeControllerAttributeBuilder->withCapabilityResources(capabilityResources)
.setOrdered(true)
.addMode(MODE_CLOSED, closeModeResource)
.addMode(MODE_OPEN, openModeResource);
return modeControllerAttributeBuilder->build();
}
protected:
/**
* Function to create ModeControllerCapabilityAgent based on the reportable flags
* and sets required ContextManager and ModeController mocks.
*/
std::shared_ptr<ModeControllerCapabilityAgent> createCapabilityAgentAndSetExpects(
const avsCommon::sdkInterfaces::modeController::ModeControllerAttributes& modeControllerAttributes,
bool proactivelyReported,
bool retrievable,
bool nonControllable);
/// The test @c ModeState as open
ModeControllerInterface::ModeState m_testModeOpen;
/// A mock @c ModeContollerInterface object.
std::shared_ptr<StrictMock<MockModeControllerInterface>> m_mockModeController;
/// A mock @c ModeContollerObserverInterface object.
std::shared_ptr<ModeControllerObserverInterface> m_observer;
// a context manager
std::shared_ptr<StrictMock<MockContextManager>> m_mockContextManager;
/// Response sender mock to track events being sent.
std::shared_ptr<MockAlexaInterfaceMessageSender> m_mockResponseSender;
// A strict mock that allows the test to strictly monitor the exceptions being sent.
std::shared_ptr<StrictMock<MockExceptionEncounteredSender>> m_mockExceptionSender;
/// A strict mock that allows the test to strictly monitor the handling of directives.
std::unique_ptr<StrictMock<MockDirectiveHandlerResult>> m_mockDirectiveHandlerResult;
};
void ModeControllerCapabilityAgentTest::SetUp() {
m_mockExceptionSender = std::make_shared<StrictMock<MockExceptionEncounteredSender>>();
m_mockDirectiveHandlerResult = make_unique<StrictMock<MockDirectiveHandlerResult>>();
m_mockModeController = std::make_shared<StrictMock<MockModeControllerInterface>>();
m_mockContextManager = std::make_shared<testing::StrictMock<MockContextManager>>();
m_mockResponseSender = std::make_shared<MockAlexaInterfaceMessageSender>();
auto timePoint = avsCommon::utils::timing::TimePoint();
timePoint.setTime_ISO_8601(TIME_OF_SAMPLE_TEST);
m_testModeOpen = ModeControllerInterface::ModeState{MODE_OPEN, timePoint, std::chrono::milliseconds(0)};
}
std::shared_ptr<ModeControllerCapabilityAgent> ModeControllerCapabilityAgentTest::createCapabilityAgentAndSetExpects(
const avsCommon::sdkInterfaces::modeController::ModeControllerAttributes& modeControllerAttributes,
bool proactivelyReported,
bool retrievable,
bool nonControllable) {
EXPECT_CALL(*m_mockModeController, getConfiguration())
.WillOnce(InvokeWithoutArgs([]() -> ModeControllerInterface::ModeControllerConfiguration {
return {MODE_OPEN, MODE_CLOSED};
}));
// ContextManager Mocks
if (retrievable) {
// Expects a non-null CA reference during create.
EXPECT_CALL(*m_mockContextManager, addStateProvider(_, ::testing::NotNull()));
// Expects a null when CA is shutdown.
EXPECT_CALL(*m_mockContextManager, removeStateProvider(_));
}
if (proactivelyReported) {
// addObserver Called during the initialization.
EXPECT_CALL(*m_mockModeController, addObserver(_))
.WillOnce(WithArg<0>(Invoke([this](std::shared_ptr<ModeControllerObserverInterface> observer) {
m_observer = observer;
return true;
})));
// removeObserver is called during the shutdown
EXPECT_CALL(*m_mockModeController, removeObserver(_))
.WillOnce(WithArg<0>(
Invoke([this](std::shared_ptr<ModeControllerObserverInterface> observer) { m_observer = nullptr; })));
}
auto modeControllerCapabilityAgent = ModeControllerCapabilityAgent::create(
TEST_ENDPOINT_ID,
TEST_INSTANCE,
modeControllerAttributes,
m_mockModeController,
m_mockContextManager,
m_mockResponseSender,
m_mockExceptionSender,
proactivelyReported,
retrievable,
nonControllable);
return modeControllerCapabilityAgent;
}
/**
* Utility function to build the @c AVSDirective for test.
*
* @param directiveName The name of the test directive to build.
* @param payload The unparsed payload of directive in JSON.
*
* @return The created AVSDirective object or @c nullptr if build failed.
*/
static std::shared_ptr<AVSDirective> buildAVSDirective(std::string directiveName, std::string payload) {
// Create Directive.
auto attachmentManager = std::make_shared<StrictMock<MockAttachmentManager>>();
auto avsMessageHeader = std::make_shared<AVSMessageHeader>(
NAMESPACE,
directiveName,
MESSAGE_ID_TEST,
DIALOG_REQUEST_ID_TEST,
CORRELATION_TOKEN_TEST,
EVENT_CORRELATION_TOKEN_TEST,
INTERFACE_VERSION,
TEST_INSTANCE);
auto avsMessageEndpoint = AVSMessageEndpoint(TEST_ENDPOINT_ID);
return AVSDirective::create("", avsMessageHeader, payload, attachmentManager, "", avsMessageEndpoint);
}
/// Test that create() returns a nullptr if called with invalid arguments.
TEST_F(ModeControllerCapabilityAgentTest, test_givenInvalidParameters_create_shouldFail) {
CapabilityResources emptyResource;
auto emptyModeControllerAttribute = buildModeControllerAttribute(emptyResource);
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
EXPECT_THAT(
ModeControllerCapabilityAgent::create(
"", "", emptyModeControllerAttribute.value(), nullptr, nullptr, nullptr, nullptr, true, true),
IsNull());
EXPECT_THAT(
ModeControllerCapabilityAgent::create(
"",
TEST_INSTANCE,
modeControllerAttributes.value(),
m_mockModeController,
m_mockContextManager,
m_mockResponseSender,
m_mockExceptionSender,
true,
true),
IsNull());
EXPECT_THAT(
ModeControllerCapabilityAgent::create(
TEST_ENDPOINT_ID,
"",
modeControllerAttributes.value(),
m_mockModeController,
m_mockContextManager,
m_mockResponseSender,
m_mockExceptionSender,
true,
true),
IsNull());
EXPECT_THAT(
ModeControllerCapabilityAgent::create(
TEST_ENDPOINT_ID,
TEST_INSTANCE,
modeControllerAttributes.value(),
nullptr,
m_mockContextManager,
m_mockResponseSender,
m_mockExceptionSender,
true,
true),
IsNull());
EXPECT_THAT(
ModeControllerCapabilityAgent::create(
TEST_ENDPOINT_ID,
TEST_INSTANCE,
modeControllerAttributes.value(),
m_mockModeController,
nullptr,
m_mockResponseSender,
m_mockExceptionSender,
true,
true),
IsNull());
EXPECT_THAT(
ModeControllerCapabilityAgent::create(
TEST_ENDPOINT_ID,
TEST_INSTANCE,
modeControllerAttributes.value(),
m_mockModeController,
m_mockContextManager,
nullptr,
m_mockExceptionSender,
true,
true),
IsNull());
EXPECT_THAT(
ModeControllerCapabilityAgent::create(
TEST_ENDPOINT_ID,
TEST_INSTANCE,
modeControllerAttributes.value(),
m_mockModeController,
m_mockContextManager,
m_mockResponseSender,
nullptr,
true,
true),
IsNull());
}
/**
* Test successful handling of SetMode directive.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_setModeDirective_successCase) {
avsCommon::utils::WaitEvent waitEvent;
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted()).WillOnce(InvokeWithoutArgs([&waitEvent]() {
waitEvent.wakeUp();
}));
EXPECT_CALL(*m_mockModeController, setMode(MODE_OPEN, _))
.WillOnce(WithArg<1>(
Invoke([](AlexaStateChangeCauseType cause) { return std::make_pair(AlexaResponseType::SUCCESS, ""); })));
EXPECT_CALL(*m_mockResponseSender, sendResponseEvent(_, _, _, _));
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), false, true, false);
ASSERT_THAT(modeControllerCapabilityAgent, NotNull());
// Simulate directive
modeControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
buildAVSDirective(NAME_SETMODE, SET_MODE_PAYLOAD_TEST), std::move(m_mockDirectiveHandlerResult));
modeControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
/**
* Test error path of SetMode directive.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_setModeDirective_errorCase) {
avsCommon::utils::WaitEvent waitEvent;
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted()).WillOnce(InvokeWithoutArgs([&waitEvent]() {
waitEvent.wakeUp();
}));
EXPECT_CALL(*m_mockModeController, setMode(MODE_OPEN, _))
.WillOnce(WithArg<1>(Invoke([](AlexaStateChangeCauseType cause) {
return std::make_pair(AlexaResponseType::ENDPOINT_UNREACHABLE, "TestEndpointNotReachable");
})));
EXPECT_CALL(*m_mockResponseSender, sendErrorResponseEvent(_, _, _, _, _));
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), true, true, false);
ASSERT_THAT(modeControllerCapabilityAgent, NotNull());
// Simulate directive
modeControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
buildAVSDirective(NAME_SETMODE, SET_MODE_PAYLOAD_TEST), std::move(m_mockDirectiveHandlerResult));
modeControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
/**
* Test successful handling of AdjustMode directive.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_adjustModeValueDirective_successCase) {
avsCommon::utils::WaitEvent waitEvent;
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted()).WillOnce(InvokeWithoutArgs([&waitEvent]() {
waitEvent.wakeUp();
}));
EXPECT_CALL(*m_mockModeController, adjustMode(MODE_DELTA, _))
.WillOnce(WithArg<1>(
Invoke([](AlexaStateChangeCauseType cause) { return std::make_pair(AlexaResponseType::SUCCESS, ""); })));
EXPECT_CALL(*m_mockResponseSender, sendResponseEvent(_, _, _, _));
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), false, true, false);
ASSERT_THAT(modeControllerCapabilityAgent, NotNull());
// Simulate directive
modeControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
buildAVSDirective(NAME_ADJUSTMODE, ADJUST_MODE_PAYLOAD_TEST), std::move(m_mockDirectiveHandlerResult));
modeControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
/**
* Test error path of AdjustMode directive.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_adjustModeValueDirective_errorCase) {
avsCommon::utils::WaitEvent waitEvent;
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted()).WillOnce(InvokeWithoutArgs([&waitEvent]() {
waitEvent.wakeUp();
}));
EXPECT_CALL(*m_mockModeController, adjustMode(MODE_DELTA, _))
.WillOnce(WithArg<1>(Invoke([](AlexaStateChangeCauseType cause) {
return std::make_pair(AlexaResponseType::ENDPOINT_UNREACHABLE, "TestEndpointNotReachable");
})));
EXPECT_CALL(*m_mockResponseSender, sendErrorResponseEvent(_, _, _, _, _));
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), true, true, false);
ASSERT_THAT(modeControllerCapabilityAgent, NotNull());
// Simulate directive
modeControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
buildAVSDirective(NAME_ADJUSTMODE, ADJUST_MODE_PAYLOAD_TEST), std::move(m_mockDirectiveHandlerResult));
modeControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
/**
* Test triggering of reportStateChange and subsequent call to the
* ContextManager to build the context.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_reportStateChange_successCase) {
avsCommon::utils::WaitEvent waitEvent;
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), true, true, false);
ASSERT_THAT(modeControllerCapabilityAgent, NotNull());
EXPECT_CALL(*m_mockModeController, setMode(MODE_OPEN, _))
.WillOnce(WithArg<1>(Invoke([this](AlexaStateChangeCauseType cause) {
m_observer->onModeChanged(m_testModeOpen, cause);
return std::make_pair(AlexaResponseType::SUCCESS, "");
})));
EXPECT_CALL(*m_mockContextManager, reportStateChange(_, _, _))
.WillOnce(InvokeWithoutArgs([modeControllerCapabilityAgent] {
const unsigned int stateRequestToken = 1;
modeControllerCapabilityAgent->provideState(
CapabilityTag(NAMESPACE, MODE_PROPERTY_NAME, TEST_ENDPOINT_ID, TEST_INSTANCE), stateRequestToken);
}));
EXPECT_CALL(*m_mockModeController, getMode())
.WillOnce(InvokeWithoutArgs([this]() -> MockModeControllerInterface::GetModeResult {
return std::make_pair(
AlexaResponseType::SUCCESS,
avsCommon::utils::Optional<ModeControllerInterface::ModeState>(m_testModeOpen));
}));
EXPECT_CALL(*m_mockContextManager, provideStateResponse(_, _, _)).WillOnce(InvokeWithoutArgs([&waitEvent]() {
waitEvent.wakeUp();
}));
m_mockModeController->setMode(MODE_OPEN, AlexaStateChangeCauseType::APP_INTERACTION);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
/**
* Test triggering of reportStateChange and subsequent failure to get the getMode and
* call to the ContextManager to report the failure.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_reportStateChange_errorCase) {
avsCommon::utils::WaitEvent waitEvent;
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), true, true, false);
ASSERT_THAT(modeControllerCapabilityAgent, NotNull());
EXPECT_CALL(*m_mockModeController, setMode(MODE_OPEN, _))
.WillOnce(WithArg<1>(Invoke([this](AlexaStateChangeCauseType cause) {
m_observer->onModeChanged(m_testModeOpen, cause);
return std::make_pair(AlexaResponseType::SUCCESS, "");
})));
EXPECT_CALL(*m_mockContextManager, reportStateChange(_, _, _))
.WillOnce(InvokeWithoutArgs([modeControllerCapabilityAgent] {
const unsigned int stateRequestToken = 1;
modeControllerCapabilityAgent->provideState(
CapabilityTag(NAMESPACE, MODE_PROPERTY_NAME, TEST_ENDPOINT_ID, TEST_INSTANCE), stateRequestToken);
}));
EXPECT_CALL(*m_mockModeController, getMode())
.WillOnce(InvokeWithoutArgs([]() -> MockModeControllerInterface::GetModeResult {
return std::make_pair(
AlexaResponseType::ENDPOINT_UNREACHABLE,
avsCommon::utils::Optional<ModeControllerInterface::ModeState>());
}));
EXPECT_CALL(*m_mockContextManager, provideStateUnavailableResponse(_, _, _))
.WillOnce(InvokeWithoutArgs([&waitEvent]() { waitEvent.wakeUp(); }));
m_mockModeController->setMode(MODE_OPEN, AlexaStateChangeCauseType::APP_INTERACTION);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
/**
* Tests unknown Directive with both proactively reported and retrievable set.
* Expect that the sendExceptionEncountered and setFailed will be called.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_unknownDirectiveWithProactivelyReportedAndRetrievableTrue) {
avsCommon::utils::WaitEvent waitEvent;
EXPECT_CALL(*m_mockExceptionSender, sendExceptionEncountered(_, _, _));
EXPECT_CALL(*m_mockDirectiveHandlerResult, setFailed(_)).WillOnce(InvokeWithoutArgs([&waitEvent]() {
waitEvent.wakeUp();
}));
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), true, true, false);
ASSERT_THAT(modeControllerCapabilityAgent, NotNull());
modeControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
buildAVSDirective(UNKNOWN_DIRECTIVE, SET_MODE_PAYLOAD_TEST), std::move(m_mockDirectiveHandlerResult));
modeControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
/**
* Tests unknown Directive with both proactively reported and retrievable as false.
* Expect that the sendExceptionEncountered and setFailed will be called.
*/
TEST_F(ModeControllerCapabilityAgentTest, test_unknownDirectiveWithProactivelyReportedAndRetrievableFalse) {
avsCommon::utils::WaitEvent waitEvent;
EXPECT_CALL(*m_mockExceptionSender, sendExceptionEncountered(_, _, _));
EXPECT_CALL(*m_mockDirectiveHandlerResult, setFailed(_)).WillOnce(InvokeWithoutArgs([&waitEvent]() {
waitEvent.wakeUp();
}));
CapabilityResources resource;
ASSERT_TRUE(resource.addFriendlyNameWithText("mode", "en-US"));
auto modeControllerAttributes = buildModeControllerAttribute(resource);
ASSERT_TRUE(modeControllerAttributes.hasValue());
auto modeControllerCapabilityAgent =
createCapabilityAgentAndSetExpects(modeControllerAttributes.value(), false, false, false);
modeControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
buildAVSDirective(UNKNOWN_DIRECTIVE, SET_MODE_PAYLOAD_TEST), std::move(m_mockDirectiveHandlerResult));
modeControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
modeControllerCapabilityAgent->shutdown();
}
} // namespace test
} // namespace modeController
} // namespace capabilityAgents
} // namespace alexaClientSDK
Reference in New Issue View Git Blame Copy Permalink