312 lines
12 KiB
C++
312 lines
12 KiB
C++
/*
|
|
* Copyright 2017-2019 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.
|
|
*/
|
|
|
|
/// @file AVSConnectionManagerTest.cpp
|
|
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <AVSCommon/AVS/Initialization/AlexaClientSDKInit.h>
|
|
#include <AVSCommon/Utils/Network/MockInternetConnectionMonitor.h>
|
|
#include "ACL/AVSConnectionManager.h"
|
|
|
|
namespace alexaClientSDK {
|
|
namespace acl {
|
|
namespace test {
|
|
|
|
using namespace ::testing;
|
|
using namespace alexaClientSDK::avsCommon::avs::initialization;
|
|
using namespace alexaClientSDK::avsCommon::sdkInterfaces;
|
|
using namespace avsCommon::utils::network::test;
|
|
|
|
/// This class allows us to test MessageObserver interaction
|
|
class MockMessageObserver : public MessageObserverInterface {
|
|
public:
|
|
MockMessageObserver() {
|
|
}
|
|
MOCK_METHOD2(receive, void(const std::string& contextId, const std::string& message));
|
|
};
|
|
|
|
/// This class allows us to test ConnectionStatusObserver interaction
|
|
class MockConnectionStatusObserver : public ConnectionStatusObserverInterface {
|
|
public:
|
|
MockConnectionStatusObserver() {
|
|
}
|
|
MOCK_METHOD2(
|
|
onConnectionStatusChanged,
|
|
void(
|
|
ConnectionStatusObserverInterface::Status status,
|
|
ConnectionStatusObserverInterface::ChangedReason reason));
|
|
};
|
|
|
|
/**
|
|
* This class allows us to test MessageRouter interaction.
|
|
*/
|
|
class MockMessageRouter : public MessageRouterInterface {
|
|
public:
|
|
MockMessageRouter() : MessageRouterInterface{"MockMessageRouter"} {
|
|
}
|
|
|
|
MOCK_METHOD0(enable, void());
|
|
MOCK_METHOD0(disable, void());
|
|
MOCK_METHOD0(doShutdown, void());
|
|
MOCK_METHOD0(getConnectionStatus, MessageRouterInterface::ConnectionStatus());
|
|
MOCK_METHOD1(sendMessage, void(std::shared_ptr<avsCommon::avs::MessageRequest> request));
|
|
MOCK_METHOD1(setAVSEndpoint, void(const std::string& avsEndpoint));
|
|
MOCK_METHOD1(setObserver, void(std::shared_ptr<MessageRouterObserverInterface> observer));
|
|
};
|
|
|
|
/// Test harness for @c AVSConnectionManager class
|
|
class AVSConnectionManagerTest : public ::testing::Test {
|
|
public:
|
|
void SetUp() override;
|
|
void TearDown() override;
|
|
|
|
std::shared_ptr<AVSConnectionManager> m_avsConnectionManager;
|
|
std::shared_ptr<MockMessageRouter> m_messageRouter;
|
|
std::shared_ptr<MockConnectionStatusObserver> m_observer;
|
|
std::shared_ptr<MockMessageObserver> m_messageObserver;
|
|
std::shared_ptr<MockInternetConnectionMonitor> m_mockConnectionMonitor;
|
|
};
|
|
|
|
void AVSConnectionManagerTest::SetUp() {
|
|
AlexaClientSDKInit::initialize(std::vector<std::shared_ptr<std::istream>>());
|
|
m_messageRouter = std::make_shared<MockMessageRouter>();
|
|
m_observer = std::make_shared<MockConnectionStatusObserver>();
|
|
m_messageObserver = std::make_shared<MockMessageObserver>();
|
|
m_mockConnectionMonitor = std::make_shared<MockInternetConnectionMonitor>();
|
|
m_avsConnectionManager = AVSConnectionManager::create(
|
|
m_messageRouter,
|
|
true,
|
|
std::unordered_set<std::shared_ptr<ConnectionStatusObserverInterface>>(),
|
|
std::unordered_set<std::shared_ptr<MessageObserverInterface>>(),
|
|
m_mockConnectionMonitor);
|
|
|
|
EXPECT_THAT(m_avsConnectionManager, NotNull());
|
|
}
|
|
|
|
void AVSConnectionManagerTest::TearDown() {
|
|
AlexaClientSDKInit::uninitialize();
|
|
}
|
|
|
|
/**
|
|
* Test @c create with valid messageRouter, ConnectionStatusObserver, MessageObservers
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_create) {
|
|
EXPECT_CALL(*m_messageRouter, setObserver(_)).Times(1);
|
|
EXPECT_CALL(*m_messageRouter, enable()).Times(1);
|
|
ASSERT_NE(nullptr, m_avsConnectionManager->create(m_messageRouter, true, {m_observer}, {m_messageObserver}));
|
|
}
|
|
|
|
/**
|
|
* Test @c create with different combinations of messageRouter, ConnectionStatusObserver, MessageObservers,
|
|
* InternetConnectionMonitor.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_createWithNullMessageRouterAndObservers) {
|
|
ASSERT_EQ(nullptr, m_avsConnectionManager->create(nullptr, true, {m_observer}, {m_messageObserver}));
|
|
ASSERT_EQ(nullptr, m_avsConnectionManager->create(m_messageRouter, true, {nullptr}, {m_messageObserver}));
|
|
ASSERT_EQ(nullptr, m_avsConnectionManager->create(m_messageRouter, true, {m_observer}, {nullptr}));
|
|
ASSERT_NE(
|
|
nullptr, m_avsConnectionManager->create(m_messageRouter, true, {m_observer}, {m_messageObserver}, nullptr));
|
|
ASSERT_NE(
|
|
nullptr,
|
|
m_avsConnectionManager->create(
|
|
m_messageRouter, true, {m_observer}, {m_messageObserver}, m_mockConnectionMonitor));
|
|
|
|
std::shared_ptr<MockConnectionStatusObserver> validConnectionStatusObserver;
|
|
validConnectionStatusObserver = std::make_shared<MockConnectionStatusObserver>();
|
|
ASSERT_EQ(
|
|
nullptr,
|
|
m_avsConnectionManager->create(
|
|
m_messageRouter, true, {m_observer, nullptr, validConnectionStatusObserver}, {m_messageObserver}));
|
|
std::shared_ptr<MockMessageObserver> validMessageObserver;
|
|
validMessageObserver = std::make_shared<MockMessageObserver>();
|
|
ASSERT_EQ(
|
|
nullptr,
|
|
m_avsConnectionManager->create(
|
|
m_messageRouter, true, {m_observer}, {m_messageObserver, nullptr, validMessageObserver}));
|
|
ASSERT_EQ(nullptr, m_avsConnectionManager->create(m_messageRouter, true, {nullptr}, {nullptr}));
|
|
// create should pass with empty set of ConnectionStatusObservers
|
|
ASSERT_NE(
|
|
nullptr,
|
|
m_avsConnectionManager->create(
|
|
m_messageRouter,
|
|
true,
|
|
std::unordered_set<std::shared_ptr<ConnectionStatusObserverInterface>>(),
|
|
{validMessageObserver}));
|
|
// create should pass with empty set of MessageObservers
|
|
ASSERT_NE(
|
|
nullptr,
|
|
m_avsConnectionManager->create(
|
|
m_messageRouter,
|
|
true,
|
|
{validConnectionStatusObserver},
|
|
std::unordered_set<std::shared_ptr<MessageObserverInterface>>()));
|
|
// create should pass with valid messageRouter, ConnectionStatusObservers and MessageObservers
|
|
ASSERT_NE(
|
|
nullptr,
|
|
m_avsConnectionManager->create(m_messageRouter, true, {validConnectionStatusObserver}, {validMessageObserver}));
|
|
}
|
|
|
|
/**
|
|
* Test addConnectionStatusObserver with a @c nullptr observer, expecting no errors.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_addConnectionStatusObserverNull) {
|
|
EXPECT_CALL(*m_messageRouter, getConnectionStatus()).Times(0);
|
|
m_avsConnectionManager->addConnectionStatusObserver(nullptr);
|
|
}
|
|
|
|
/**
|
|
* Test with addConnectionStatusObserver with MockConnectionStatusObserver.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_addConnectionStatusObserverValid) {
|
|
EXPECT_CALL(*m_observer, onConnectionStatusChanged(_, _)).Times(1);
|
|
m_avsConnectionManager->addConnectionStatusObserver(m_observer);
|
|
}
|
|
|
|
/**
|
|
* Test removeConnectionStatusObserver with a @c nullptr observer, expecting no errors.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_removeConnectionStatusObserverNull) {
|
|
m_avsConnectionManager->removeConnectionStatusObserver(nullptr);
|
|
}
|
|
|
|
/**
|
|
* Test addMessageObserver with a @c nullptr observer, expecting no errors.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_addMessageObserverNull) {
|
|
m_avsConnectionManager->addMessageObserver(nullptr);
|
|
}
|
|
|
|
/**
|
|
* Test removeMessageObserver with a @c nullptr observer, expecting no errors.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_removeMessageObserverNull) {
|
|
m_avsConnectionManager->removeMessageObserver(nullptr);
|
|
}
|
|
|
|
/**
|
|
* Test enable and disable function of AVSConnectionManager
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_enableAndDisableFunction) {
|
|
EXPECT_CALL(*m_messageRouter, enable()).Times(1);
|
|
m_avsConnectionManager->enable();
|
|
ASSERT_TRUE(m_avsConnectionManager->isEnabled());
|
|
EXPECT_CALL(*m_messageRouter, disable()).Times(1);
|
|
m_avsConnectionManager->disable();
|
|
ASSERT_FALSE(m_avsConnectionManager->isEnabled());
|
|
}
|
|
|
|
/**
|
|
* Tests sendMessage with a @c nullptr request, expecting no errors.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_sendMessageRequest) {
|
|
EXPECT_CALL(*m_messageRouter, sendMessage(_)).Times(1);
|
|
m_avsConnectionManager->sendMessage(nullptr);
|
|
EXPECT_CALL(*m_messageRouter, sendMessage(_)).Times(1);
|
|
std::shared_ptr<avsCommon::avs::MessageRequest> messageRequest;
|
|
messageRequest = std::make_shared<avsCommon::avs::MessageRequest>("Test message");
|
|
m_avsConnectionManager->sendMessage(messageRequest);
|
|
}
|
|
|
|
/**
|
|
* Test setAVSEndpoint and expect a call to messageRouter's setAVSEndpoint.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_setAVSEndpoint) {
|
|
EXPECT_CALL(*m_messageRouter, setAVSEndpoint(_)).Times(1);
|
|
m_avsConnectionManager->setAVSEndpoint("AVSEndpoint");
|
|
}
|
|
|
|
/**
|
|
* Test that onConnectionStatusChanged(false) results in a reconnect attempt when enabled.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_enabledOnConnectStatusChangedToFalse) {
|
|
// Create a new MessageRouter so we don't get residual calls to m_messageRouter from SetUp().
|
|
auto messageRouter = std::make_shared<MockMessageRouter>();
|
|
|
|
{
|
|
InSequence dummy;
|
|
EXPECT_CALL(*messageRouter, enable());
|
|
EXPECT_CALL(*messageRouter, disable());
|
|
EXPECT_CALL(*messageRouter, enable());
|
|
}
|
|
|
|
m_avsConnectionManager = AVSConnectionManager::create(
|
|
messageRouter,
|
|
true,
|
|
std::unordered_set<std::shared_ptr<ConnectionStatusObserverInterface>>(),
|
|
std::unordered_set<std::shared_ptr<MessageObserverInterface>>());
|
|
m_avsConnectionManager->onConnectionStatusChanged(false);
|
|
// Explicitly reset so we control when destructor is called and can set expectations accordingly.
|
|
m_avsConnectionManager.reset();
|
|
}
|
|
|
|
/**
|
|
* Test that onConnectionStatusChanged(true) results in a no-op when enabled.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_enabledOnConnectStatusChangedToTrue) {
|
|
// Create a new MessageRouter so we don't get residual calls to m_messageRouter from SetUp().
|
|
auto messageRouter = std::make_shared<MockMessageRouter>();
|
|
|
|
{
|
|
InSequence dummy;
|
|
EXPECT_CALL(*messageRouter, enable()).Times(1);
|
|
EXPECT_CALL(*messageRouter, disable()).Times(0);
|
|
EXPECT_CALL(*messageRouter, enable()).Times(0);
|
|
}
|
|
|
|
m_avsConnectionManager = AVSConnectionManager::create(
|
|
messageRouter,
|
|
true,
|
|
std::unordered_set<std::shared_ptr<ConnectionStatusObserverInterface>>(),
|
|
std::unordered_set<std::shared_ptr<MessageObserverInterface>>());
|
|
m_avsConnectionManager->onConnectionStatusChanged(true);
|
|
// Explicitly reset so we control when destructor is called and can set expectations accordingly.
|
|
m_avsConnectionManager.reset();
|
|
}
|
|
|
|
/**
|
|
* Test that onConnectionStatusChanged() results in no reconnect attempts when disabled.
|
|
*/
|
|
TEST_F(AVSConnectionManagerTest, test_disabledOnConnectStatusChanged) {
|
|
// Create a new MessageRouter so we don't get residual calls to m_messageRouter from SetUp().
|
|
auto messageRouter = std::make_shared<MockMessageRouter>();
|
|
|
|
{
|
|
InSequence dummy;
|
|
EXPECT_CALL(*messageRouter, enable()).Times(0);
|
|
EXPECT_CALL(*messageRouter, disable()).Times(0);
|
|
}
|
|
|
|
m_avsConnectionManager = AVSConnectionManager::create(
|
|
messageRouter,
|
|
false,
|
|
std::unordered_set<std::shared_ptr<ConnectionStatusObserverInterface>>(),
|
|
std::unordered_set<std::shared_ptr<MessageObserverInterface>>());
|
|
m_avsConnectionManager->onConnectionStatusChanged(true);
|
|
m_avsConnectionManager->onConnectionStatusChanged(false);
|
|
// Explicitly reset so we control when destructor is called and can set expectations accordingly.
|
|
m_avsConnectionManager.reset();
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace acl
|
|
} // namespace alexaClientSDK
|
|
|
|
int main(int argc, char** argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|