442 lines
18 KiB
C++
442 lines
18 KiB
C++
/*
|
|
* 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 "PowerController/PowerControllerCapabilityAgent.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/PowerController/PowerControllerInterface.h>
|
|
#include <AVSCommon/Utils/Memory/Memory.h>
|
|
#include <AVSCommon/Utils/Timing/TimePoint.h>
|
|
#include <AVSCommon/Utils/WaitEvent.h>
|
|
|
|
namespace alexaClientSDK {
|
|
namespace capabilityAgents {
|
|
namespace powerController {
|
|
namespace test {
|
|
|
|
using namespace avsCommon::avs;
|
|
using namespace avsCommon::avs::attachment::test;
|
|
using namespace avsCommon::sdkInterfaces;
|
|
using namespace avsCommon::sdkInterfaces::powerController;
|
|
using namespace avsCommon::sdkInterfaces::test;
|
|
using namespace avsCommon::utils::memory;
|
|
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.PowerController"};
|
|
|
|
/// The supported version
|
|
static const std::string INTERFACE_VERSION{"3"};
|
|
|
|
/// The name for TurnOn directive
|
|
static const std::string NAME_TURNON{"TurnOn"};
|
|
|
|
/// The name for TurnOff directive
|
|
static const std::string NAME_TURNOFF{"TurnOff"};
|
|
|
|
/// The name for powerState property
|
|
static const std::string POWERSTATE_PROPERTY_NAME{"powerState"};
|
|
|
|
/// Json value for ON power state
|
|
static const std::string POWERSTATE_ON{R"("ON")"};
|
|
|
|
/// Json value for OFF power state
|
|
static const std::string POWERSTATE_OFF{R"("OFF")"};
|
|
|
|
/// An unknown directive signature.
|
|
static const std::string UNKNOWN_DIRECTIVE{"Unknown"};
|
|
|
|
/// The test EndpointId
|
|
static const EndpointIdentifier TEST_ENDPOINT_ID("testEndpointId");
|
|
|
|
/// 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");
|
|
|
|
class MockPowerControllerInterface : public PowerControllerInterface {
|
|
public:
|
|
using SetPowerStateResult = std::pair<AlexaResponseType, std::string>;
|
|
using GetPowerStateResult = std::pair<AlexaResponseType, avsCommon::utils::Optional<PowerState>>;
|
|
|
|
MOCK_METHOD2(setPowerState, SetPowerStateResult(const bool state, const AlexaStateChangeCauseType cause));
|
|
MOCK_METHOD0(getPowerState, GetPowerStateResult());
|
|
MOCK_METHOD1(addObserver, bool(std::shared_ptr<PowerControllerObserverInterface>));
|
|
MOCK_METHOD1(removeObserver, void(const std::shared_ptr<PowerControllerObserverInterface>&));
|
|
};
|
|
|
|
class PowerControllerCapabilityAgentTest : public ::testing::Test {
|
|
public:
|
|
/// SetUp before each test case.
|
|
void SetUp() override;
|
|
|
|
/// Clean up the test harness after running a test.
|
|
void TearDown() override;
|
|
|
|
/// Constructor.
|
|
PowerControllerCapabilityAgentTest() {
|
|
}
|
|
|
|
protected:
|
|
/**
|
|
* Function to create PowerControllerCapabilityAgent based on the reportable flags
|
|
* and sets required ContextManager and PowerController mocks.
|
|
*/
|
|
std::shared_ptr<PowerControllerCapabilityAgent> createCapabilityAgentAndSetExpects(
|
|
bool proactivelyReported,
|
|
bool retrievable);
|
|
|
|
/// The test @c PowerState as ON
|
|
PowerControllerInterface::PowerState m_testPowerStateOn;
|
|
|
|
/// A mock @c PowerContollerInterface object.
|
|
std::shared_ptr<StrictMock<MockPowerControllerInterface>> m_mockPowerController;
|
|
|
|
/// A mock @c PowerContollerObserverInterface object.
|
|
std::shared_ptr<PowerControllerObserverInterface> 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 PowerControllerCapabilityAgentTest::SetUp() {
|
|
m_mockExceptionSender = std::make_shared<StrictMock<MockExceptionEncounteredSender>>();
|
|
m_mockDirectiveHandlerResult = make_unique<StrictMock<MockDirectiveHandlerResult>>();
|
|
m_mockPowerController = std::make_shared<StrictMock<MockPowerControllerInterface>>();
|
|
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_testPowerStateOn = PowerControllerInterface::PowerState{true, timePoint, std::chrono::milliseconds(0)};
|
|
}
|
|
|
|
void PowerControllerCapabilityAgentTest::TearDown() {
|
|
}
|
|
|
|
std::shared_ptr<PowerControllerCapabilityAgent> PowerControllerCapabilityAgentTest::createCapabilityAgentAndSetExpects(
|
|
bool proactivelyReported,
|
|
bool retrievable) {
|
|
// 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_mockPowerController, addObserver(_))
|
|
.WillOnce(WithArg<0>(Invoke([this](std::shared_ptr<PowerControllerObserverInterface> observer) {
|
|
m_observer = observer;
|
|
return true;
|
|
})));
|
|
|
|
// removeObserver is called during the shutdown
|
|
EXPECT_CALL(*m_mockPowerController, removeObserver(_))
|
|
.WillOnce(WithArg<0>(
|
|
Invoke([this](std::shared_ptr<PowerControllerObserverInterface> observer) { m_observer = nullptr; })));
|
|
}
|
|
|
|
auto powerControllerCapabilityAgent = PowerControllerCapabilityAgent::create(
|
|
TEST_ENDPOINT_ID,
|
|
m_mockPowerController,
|
|
m_mockContextManager,
|
|
m_mockResponseSender,
|
|
m_mockExceptionSender,
|
|
proactivelyReported,
|
|
retrievable);
|
|
return powerControllerCapabilityAgent;
|
|
}
|
|
|
|
std::shared_ptr<AVSDirective> buildAVSDirective(std::string directiveName) {
|
|
// 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, INTERFACE_VERSION);
|
|
auto avsMessageEndpoint = AVSMessageEndpoint(TEST_ENDPOINT_ID);
|
|
|
|
return AVSDirective::create("", avsMessageHeader, "", attachmentManager, "", avsMessageEndpoint);
|
|
}
|
|
|
|
/// Test that create() returns a nullptr if called with invalid arguments.
|
|
TEST_F(PowerControllerCapabilityAgentTest, test_givenInvalidParameters_create_shouldFail) {
|
|
ASSERT_THAT(
|
|
PowerControllerCapabilityAgent::create(
|
|
"", m_mockPowerController, m_mockContextManager, m_mockResponseSender, m_mockExceptionSender, true, true),
|
|
IsNull());
|
|
ASSERT_THAT(
|
|
PowerControllerCapabilityAgent::create(
|
|
TEST_ENDPOINT_ID, nullptr, m_mockContextManager, m_mockResponseSender, m_mockExceptionSender, true, true),
|
|
IsNull());
|
|
ASSERT_THAT(
|
|
PowerControllerCapabilityAgent::create(
|
|
TEST_ENDPOINT_ID, m_mockPowerController, nullptr, m_mockResponseSender, m_mockExceptionSender, true, true),
|
|
IsNull());
|
|
ASSERT_THAT(
|
|
PowerControllerCapabilityAgent::create(
|
|
TEST_ENDPOINT_ID, m_mockPowerController, m_mockContextManager, nullptr, m_mockExceptionSender, true, true),
|
|
IsNull());
|
|
ASSERT_THAT(
|
|
PowerControllerCapabilityAgent::create(
|
|
TEST_ENDPOINT_ID, m_mockPowerController, m_mockContextManager, m_mockResponseSender, nullptr, true, true),
|
|
IsNull());
|
|
}
|
|
|
|
/**
|
|
* Test successful handling of TurnOn directive.
|
|
*/
|
|
TEST_F(PowerControllerCapabilityAgentTest, test_turnOnDirective_successCase) {
|
|
avsCommon::utils::WaitEvent waitEvent;
|
|
|
|
EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted()).WillOnce(InvokeWithoutArgs([&waitEvent]() {
|
|
waitEvent.wakeUp();
|
|
}));
|
|
|
|
EXPECT_CALL(*m_mockPowerController, setPowerState(true, _))
|
|
.WillOnce(WithArg<1>(
|
|
Invoke([](AlexaStateChangeCauseType cause) { return std::make_pair(AlexaResponseType::SUCCESS, ""); })));
|
|
|
|
EXPECT_CALL(*m_mockResponseSender, sendResponseEvent(_, _, _, _));
|
|
|
|
auto powerControllerCapabilityAgent = createCapabilityAgentAndSetExpects(false, true);
|
|
ASSERT_THAT(powerControllerCapabilityAgent, NotNull());
|
|
|
|
// Simulate directive
|
|
powerControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
|
|
buildAVSDirective(NAME_TURNON), std::move(m_mockDirectiveHandlerResult));
|
|
powerControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
|
|
|
|
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
|
|
|
|
powerControllerCapabilityAgent->shutdown();
|
|
}
|
|
|
|
/**
|
|
* Test error path of TurnOn directive.
|
|
*/
|
|
TEST_F(PowerControllerCapabilityAgentTest, test_turnOnDirective_errorCase) {
|
|
avsCommon::utils::WaitEvent waitEvent;
|
|
|
|
EXPECT_CALL(*m_mockDirectiveHandlerResult, setCompleted()).WillOnce(InvokeWithoutArgs([&waitEvent]() {
|
|
waitEvent.wakeUp();
|
|
}));
|
|
|
|
EXPECT_CALL(*m_mockPowerController, setPowerState(true, _))
|
|
.WillOnce(WithArg<1>(Invoke([](AlexaStateChangeCauseType cause) {
|
|
return std::make_pair(AlexaResponseType::ENDPOINT_UNREACHABLE, "TestEndpointNotReachable");
|
|
})));
|
|
|
|
EXPECT_CALL(*m_mockResponseSender, sendErrorResponseEvent(_, _, _, _, _));
|
|
|
|
auto powerControllerCapabilityAgent = createCapabilityAgentAndSetExpects(true, true);
|
|
ASSERT_THAT(powerControllerCapabilityAgent, NotNull());
|
|
|
|
// Simulate directive
|
|
powerControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
|
|
buildAVSDirective(NAME_TURNON), std::move(m_mockDirectiveHandlerResult));
|
|
powerControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
|
|
|
|
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
|
|
|
|
powerControllerCapabilityAgent->shutdown();
|
|
}
|
|
|
|
/**
|
|
* Test triggering of reportStateChange and subsequent call to the
|
|
* ContextManager to build the context.
|
|
*/
|
|
TEST_F(PowerControllerCapabilityAgentTest, test_reportStateChange_successCase) {
|
|
avsCommon::utils::WaitEvent waitEvent;
|
|
auto powerControllerCapabilityAgent = createCapabilityAgentAndSetExpects(true, true);
|
|
ASSERT_THAT(powerControllerCapabilityAgent, NotNull());
|
|
|
|
// TurnOn case
|
|
EXPECT_CALL(*m_mockPowerController, setPowerState(true, _))
|
|
.WillOnce(WithArg<1>(Invoke([this](AlexaStateChangeCauseType cause) {
|
|
m_observer->onPowerStateChanged(m_testPowerStateOn, cause);
|
|
return std::make_pair(AlexaResponseType::SUCCESS, "");
|
|
})));
|
|
|
|
EXPECT_CALL(*m_mockContextManager, reportStateChange(_, _, _))
|
|
.WillOnce(InvokeWithoutArgs([powerControllerCapabilityAgent] {
|
|
const unsigned int stateRequestToken = 1;
|
|
powerControllerCapabilityAgent->provideState(
|
|
CapabilityTag(NAMESPACE, POWERSTATE_PROPERTY_NAME, TEST_ENDPOINT_ID), stateRequestToken);
|
|
}));
|
|
|
|
EXPECT_CALL(*m_mockPowerController, getPowerState())
|
|
.WillOnce(InvokeWithoutArgs([this]() -> MockPowerControllerInterface::GetPowerStateResult {
|
|
return std::make_pair(
|
|
AlexaResponseType::SUCCESS,
|
|
avsCommon::utils::Optional<PowerControllerInterface::PowerState>(m_testPowerStateOn));
|
|
}));
|
|
|
|
EXPECT_CALL(*m_mockContextManager, provideStateResponse(_, _, _)).WillOnce(InvokeWithoutArgs([&waitEvent]() {
|
|
waitEvent.wakeUp();
|
|
}));
|
|
|
|
m_mockPowerController->setPowerState(true, AlexaStateChangeCauseType::APP_INTERACTION);
|
|
|
|
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
|
|
|
|
powerControllerCapabilityAgent->shutdown();
|
|
}
|
|
|
|
/**
|
|
* Test triggering of reportStateChange and subsequent failure to get the getPowerState and
|
|
* call to the ContextManager to report the failure.
|
|
*/
|
|
TEST_F(PowerControllerCapabilityAgentTest, test_reportStateChange_errorCase) {
|
|
avsCommon::utils::WaitEvent waitEvent;
|
|
auto powerControllerCapabilityAgent = createCapabilityAgentAndSetExpects(true, true);
|
|
ASSERT_THAT(powerControllerCapabilityAgent, NotNull());
|
|
|
|
// TurnOn case
|
|
EXPECT_CALL(*m_mockPowerController, setPowerState(true, _))
|
|
.WillOnce(WithArg<1>(Invoke([this](AlexaStateChangeCauseType cause) {
|
|
m_observer->onPowerStateChanged(m_testPowerStateOn, cause);
|
|
return std::make_pair(AlexaResponseType::SUCCESS, "");
|
|
})));
|
|
|
|
EXPECT_CALL(*m_mockContextManager, reportStateChange(_, _, _))
|
|
.WillOnce(InvokeWithoutArgs([powerControllerCapabilityAgent] {
|
|
const unsigned int stateRequestToken = 1;
|
|
powerControllerCapabilityAgent->provideState(
|
|
CapabilityTag(NAMESPACE, POWERSTATE_PROPERTY_NAME, TEST_ENDPOINT_ID), stateRequestToken);
|
|
}));
|
|
|
|
EXPECT_CALL(*m_mockPowerController, getPowerState())
|
|
.WillOnce(InvokeWithoutArgs([]() -> MockPowerControllerInterface::GetPowerStateResult {
|
|
return std::make_pair(
|
|
AlexaResponseType::ENDPOINT_UNREACHABLE,
|
|
avsCommon::utils::Optional<PowerControllerInterface::PowerState>());
|
|
}));
|
|
|
|
EXPECT_CALL(*m_mockContextManager, provideStateUnavailableResponse(_, _, _))
|
|
.WillOnce(InvokeWithoutArgs([&waitEvent]() { waitEvent.wakeUp(); }));
|
|
|
|
m_mockPowerController->setPowerState(true, AlexaStateChangeCauseType::APP_INTERACTION);
|
|
|
|
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
|
|
|
|
powerControllerCapabilityAgent->shutdown();
|
|
}
|
|
|
|
/**
|
|
* Tests unknown Directive with both proactively reported and retrievable set.
|
|
* Expect that the sendExceptionEncountered and setFailed will be called.
|
|
*/
|
|
TEST_F(PowerControllerCapabilityAgentTest, test_unknownDirectiveWithProactivelyReportedAndRetrievableTrue) {
|
|
avsCommon::utils::WaitEvent waitEvent;
|
|
|
|
EXPECT_CALL(*m_mockExceptionSender, sendExceptionEncountered(_, _, _));
|
|
EXPECT_CALL(*m_mockDirectiveHandlerResult, setFailed(_)).WillOnce(InvokeWithoutArgs([&waitEvent]() {
|
|
waitEvent.wakeUp();
|
|
}));
|
|
|
|
auto powerControllerCapabilityAgent = createCapabilityAgentAndSetExpects(true, true);
|
|
ASSERT_THAT(powerControllerCapabilityAgent, NotNull());
|
|
|
|
powerControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
|
|
buildAVSDirective(UNKNOWN_DIRECTIVE), std::move(m_mockDirectiveHandlerResult));
|
|
powerControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
|
|
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
|
|
powerControllerCapabilityAgent->shutdown();
|
|
}
|
|
|
|
/**
|
|
* Tests unknown Directive with both proactively reported and retrievable as false.
|
|
* Expect that the sendExceptionEncountered and setFailed will be called.
|
|
*/
|
|
TEST_F(PowerControllerCapabilityAgentTest, test_unknownDirectiveWithProactivelyReportedAndRetrievableFalse) {
|
|
avsCommon::utils::WaitEvent waitEvent;
|
|
|
|
EXPECT_CALL(*m_mockExceptionSender, sendExceptionEncountered(_, _, _));
|
|
EXPECT_CALL(*m_mockDirectiveHandlerResult, setFailed(_)).WillOnce(InvokeWithoutArgs([&waitEvent]() {
|
|
waitEvent.wakeUp();
|
|
}));
|
|
|
|
auto powerControllerCapabilityAgent = createCapabilityAgentAndSetExpects(false, false);
|
|
ASSERT_THAT(powerControllerCapabilityAgent, NotNull());
|
|
|
|
powerControllerCapabilityAgent->CapabilityAgent::preHandleDirective(
|
|
buildAVSDirective(UNKNOWN_DIRECTIVE), std::move(m_mockDirectiveHandlerResult));
|
|
powerControllerCapabilityAgent->CapabilityAgent::handleDirective(MESSAGE_ID_TEST);
|
|
EXPECT_TRUE(waitEvent.wait(TIMEOUT));
|
|
powerControllerCapabilityAgent->shutdown();
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace powerController
|
|
} // namespace capabilityAgents
|
|
} // namespace alexaClientSDK
|