353 lines
13 KiB
C++
353 lines
13 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 "MessageRouterTest.h"
|
|
#include <gtest/gtest.h>
|
|
|
|
namespace alexaClientSDK {
|
|
namespace acl {
|
|
namespace test {
|
|
|
|
using namespace alexaClientSDK::avsCommon::sdkInterfaces;
|
|
|
|
TEST_F(MessageRouterTest, test_getConnectionStatusReturnsDisconnectedBeforeConnect) {
|
|
ASSERT_EQ(m_router->getConnectionStatus().first, ConnectionStatusObserverInterface::Status::DISCONNECTED);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_getConnectionStatusReturnsPendingAfterConnectingStarts) {
|
|
setupStateToPending();
|
|
ASSERT_EQ(m_router->getConnectionStatus().first, ConnectionStatusObserverInterface::Status::PENDING);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_getConnectionStatusReturnsConnectedAfterConnectionEstablished) {
|
|
setupStateToConnected();
|
|
ASSERT_EQ(m_router->getConnectionStatus().first, ConnectionStatusObserverInterface::Status::CONNECTED);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_getConnectionStatusReturnsConnectedAfterDisconnected) {
|
|
m_router->onDisconnected(m_mockTransport, ConnectionStatusObserverInterface::ChangedReason::ACL_DISABLED);
|
|
ASSERT_EQ(m_router->getConnectionStatus().first, ConnectionStatusObserverInterface::Status::DISCONNECTED);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_ensureTheMessageRouterObserverIsInformedOfConnectionPendingAfterConnect) {
|
|
setupStateToPending();
|
|
|
|
// wait for the result to propagate by scheduling a task on the client executor
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(), ConnectionStatusObserverInterface::Status::PENDING);
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionChangedReason(),
|
|
ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_ensureTheMessageRouterObserverIsInformedOfNewConnection) {
|
|
setupStateToConnected();
|
|
|
|
// wait for the result to propagate by scheduling a task on the client executor
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(), ConnectionStatusObserverInterface::Status::CONNECTED);
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionChangedReason(),
|
|
ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_ensureTheMessageRouterObserverIsInformedOfTransportDisconnection) {
|
|
setupStateToConnected();
|
|
|
|
auto reason = ConnectionStatusObserverInterface::ChangedReason::ACL_DISABLED;
|
|
disconnectMockTransport(m_mockTransport.get());
|
|
m_router->onDisconnected(m_mockTransport, reason);
|
|
|
|
// wait for the result to propagate by scheduling a task on the client executor
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(), ConnectionStatusObserverInterface::Status::PENDING);
|
|
ASSERT_EQ(m_mockMessageRouterObserver->getLatestConnectionChangedReason(), reason);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_ensureTheMessageRouterObserverIsInformedOfRouterDisconnection) {
|
|
setupStateToConnected();
|
|
|
|
m_router->disable();
|
|
|
|
// wait for the result to propagate by scheduling a task on the client executor
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(),
|
|
ConnectionStatusObserverInterface::Status::DISCONNECTED);
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionChangedReason(),
|
|
ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_sendIsSuccessfulWhenConnected) {
|
|
setupStateToConnected();
|
|
|
|
auto messageRequest = createMessageRequest();
|
|
|
|
// Expect to have the message sent to the transport
|
|
EXPECT_CALL(*m_mockTransport, onRequestEnqueued()).Times(1);
|
|
|
|
m_router->sendMessage(messageRequest);
|
|
|
|
// Since we connected we will be disconnected when the router is destroyed
|
|
EXPECT_CALL(*m_mockTransport, disconnect()).Times(AnyNumber());
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_sendFailsWhenDisconnected) {
|
|
auto messageRequest = createMessageRequest();
|
|
|
|
// Expect to have the message to be enqueued but the transport is not notified
|
|
EXPECT_CALL(*m_mockTransport, onRequestEnqueued()).Times(0);
|
|
|
|
m_router->sendMessage(messageRequest);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_sendFailsWhenPending) {
|
|
// Ensure a transport exists
|
|
initializeMockTransport(m_mockTransport.get());
|
|
m_router->enable();
|
|
|
|
auto messageRequest = createMessageRequest();
|
|
|
|
// Expect to have the message sent to the transport.
|
|
EXPECT_CALL(*m_mockTransport, onRequestEnqueued()).Times(1);
|
|
|
|
m_router->sendMessage(messageRequest);
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_sendMessageDoesNotSendAfterDisconnected) {
|
|
setupStateToConnected();
|
|
|
|
auto messageRequest = createMessageRequest();
|
|
|
|
EXPECT_CALL(*m_mockTransport, doShutdown()).Times(AtLeast(1));
|
|
m_router->disable();
|
|
|
|
// Expect to have the message sent to the transport
|
|
EXPECT_CALL(*m_mockTransport, onRequestEnqueued()).Times(0);
|
|
|
|
m_router->sendMessage(messageRequest);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_shutdownCalledWithMultipleMessages) {
|
|
setupStateToConnected();
|
|
|
|
// wait for the result to propagate by scheduling a task on the client executor
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(), ConnectionStatusObserverInterface::Status::CONNECTED);
|
|
|
|
auto firstRequest = createMessageRequest();
|
|
auto otherRequest = createMessageRequest();
|
|
|
|
auto firstObserver = createObserver();
|
|
auto otherObserver = createObserver();
|
|
|
|
firstRequest->addObserver(firstObserver);
|
|
otherRequest->addObserver(otherObserver);
|
|
|
|
m_router->sendMessage(firstRequest);
|
|
m_router->sendMessage(otherRequest);
|
|
|
|
m_router->shutdown();
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(),
|
|
ConnectionStatusObserverInterface::Status::DISCONNECTED);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionChangedReason(),
|
|
ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
|
|
ASSERT_EQ(firstObserver->m_status.getValue(), MessageRequestObserverInterface::Status::NOT_CONNECTED);
|
|
ASSERT_EQ(otherObserver->m_status.getValue(), MessageRequestObserverInterface::Status::NOT_CONNECTED);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_serverSideDisconnectWithLongDelayedReconnectReportsPending) {
|
|
/*
|
|
* This test is difficult to setup in a nice way. The idea is to replace the original
|
|
* transport with a new one, call onServerSideDisconnect to make it the new active
|
|
* transport, and then send a message. The message should be sent on the new transport.
|
|
*/
|
|
setupStateToConnected();
|
|
|
|
auto oldTransport = m_mockTransport;
|
|
|
|
auto newTransport = std::make_shared<NiceMock<MockTransport>>();
|
|
initializeMockTransport(newTransport.get());
|
|
|
|
m_transportFactory->setMockTransport(newTransport);
|
|
|
|
// Trigger server side disconnect handling
|
|
m_router->onServerSideDisconnect(oldTransport);
|
|
|
|
// Simulate delayed reconnect, waiting for the server side disconnect grace period to expire so
|
|
// so that we can see the transition back to the PENDING state.
|
|
ASSERT_TRUE(m_mockMessageRouterObserver->waitForStatusChange(
|
|
TestableMessageRouter::SHORT_SERVER_SIDE_DISCONNECT_GRACE_PERIOD + SHORT_TIMEOUT_MS,
|
|
ConnectionStatusObserverInterface::Status::PENDING,
|
|
ConnectionStatusObserverInterface::ChangedReason::SERVER_SIDE_DISCONNECT))
|
|
<< "status=" << m_mockMessageRouterObserver->getLatestConnectionStatus()
|
|
<< "reason=" << m_mockMessageRouterObserver->getLatestConnectionChangedReason();
|
|
|
|
// mock the new transports connection
|
|
connectMockTransport(newTransport.get());
|
|
m_router->onConnected(newTransport);
|
|
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(), ConnectionStatusObserverInterface::Status::CONNECTED);
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionChangedReason(),
|
|
ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
|
|
// mock the old transport disconnecting completely
|
|
disconnectMockTransport(oldTransport.get());
|
|
m_router->onDisconnected(oldTransport, ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
|
|
auto messageRequest = createMessageRequest();
|
|
|
|
EXPECT_CALL(*oldTransport.get(), onRequestEnqueued()).Times(0);
|
|
|
|
EXPECT_CALL(*newTransport.get(), onRequestEnqueued()).Times(1);
|
|
|
|
m_router->sendMessage(messageRequest);
|
|
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, test_serverSideDisconnectWithReconnectDoesNotReportingPending) {
|
|
/*
|
|
* This test is difficult to setup in a nice way. The idea is to replace the original
|
|
* transport with a new one, call onServerSideDisconnect to make it the new active
|
|
* transport, and then send a message. The message should be sent on the new transport.
|
|
*/
|
|
setupStateToConnected();
|
|
|
|
auto oldTransport = m_mockTransport;
|
|
|
|
auto newTransport = std::make_shared<NiceMock<MockTransport>>();
|
|
initializeMockTransport(newTransport.get());
|
|
|
|
m_transportFactory->setMockTransport(newTransport);
|
|
|
|
// Trigger server side disconnect handling
|
|
m_router->onServerSideDisconnect(oldTransport);
|
|
|
|
// Simulate slightly delayed reconnect, verifying that no transition to PENDING is reported.
|
|
ASSERT_FALSE(m_mockMessageRouterObserver->waitForStatusChange(
|
|
SHORT_TIMEOUT_MS,
|
|
ConnectionStatusObserverInterface::Status::PENDING,
|
|
ConnectionStatusObserverInterface::ChangedReason::SERVER_SIDE_DISCONNECT))
|
|
<< "status=" << m_mockMessageRouterObserver->getLatestConnectionStatus()
|
|
<< "reason=" << m_mockMessageRouterObserver->getLatestConnectionChangedReason();
|
|
|
|
// mock the new transports connection
|
|
connectMockTransport(newTransport.get());
|
|
m_router->onConnected(newTransport);
|
|
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionStatus(), ConnectionStatusObserverInterface::Status::CONNECTED);
|
|
ASSERT_EQ(
|
|
m_mockMessageRouterObserver->getLatestConnectionChangedReason(),
|
|
ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
|
|
// mock the old transport disconnecting completely
|
|
disconnectMockTransport(oldTransport.get());
|
|
m_router->onDisconnected(oldTransport, ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
|
|
|
|
auto messageRequest = createMessageRequest();
|
|
|
|
EXPECT_CALL(*oldTransport.get(), onRequestEnqueued()).Times(0);
|
|
|
|
EXPECT_CALL(*newTransport.get(), onRequestEnqueued()).Times(1);
|
|
|
|
m_router->sendMessage(messageRequest);
|
|
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
}
|
|
|
|
/**
|
|
* This tests the calling of private method @c receive() for MessageRouterObserver from MessageRouter
|
|
*/
|
|
TEST_F(MessageRouterTest, test_onReceive) {
|
|
m_mockMessageRouterObserver->reset();
|
|
m_router->consumeMessage(CONTEXT_ID, MESSAGE);
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
ASSERT_TRUE(m_mockMessageRouterObserver->wasNotifiedOfReceive());
|
|
ASSERT_EQ(CONTEXT_ID, m_mockMessageRouterObserver->getAttachmentContextId());
|
|
ASSERT_EQ(MESSAGE, m_mockMessageRouterObserver->getLatestMessage());
|
|
}
|
|
|
|
/**
|
|
* This tests the calling of private method @c onConnectionStatusChanged()
|
|
* for MessageRouterObserver from MessageRouter
|
|
*/
|
|
TEST_F(MessageRouterTest, test_onConnectionStatusChanged) {
|
|
m_mockMessageRouterObserver->reset();
|
|
setupStateToConnected();
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
ASSERT_TRUE(m_mockMessageRouterObserver->wasNotifiedOfStatusChange());
|
|
}
|
|
|
|
/**
|
|
* Verify that when enable is called with active connection is pending
|
|
* we don't create a new connection.
|
|
*/
|
|
TEST_F(MessageRouterTest, test_enableTwiceOnPendingTransport) {
|
|
setupStateToPending();
|
|
waitOnMessageRouter(SHORT_TIMEOUT_MS);
|
|
m_mockMessageRouterObserver->reset();
|
|
|
|
EXPECT_CALL(*m_mockTransport, connect()).Times(0);
|
|
|
|
m_router->enable();
|
|
|
|
ASSERT_FALSE(m_mockMessageRouterObserver->wasNotifiedOfStatusChange());
|
|
}
|
|
|
|
/**
|
|
* Verify that if onConnected is called
|
|
* for inactive transport, we don't notify the observers and
|
|
* closing the connection.
|
|
*/
|
|
TEST_F(MessageRouterTest, test_onConnectedOnInactiveTransport) {
|
|
auto transport = std::make_shared<MockTransport>();
|
|
m_router->onConnected(transport);
|
|
ASSERT_FALSE(m_mockMessageRouterObserver->wasNotifiedOfStatusChange());
|
|
}
|
|
|
|
TEST_F(MessageRouterTest, setAndGetAVSGateway) {
|
|
auto gateway = "Gateway";
|
|
m_router->setAVSGateway(gateway);
|
|
ASSERT_EQ(gateway, m_router->getAVSGateway());
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace acl
|
|
} // namespace alexaClientSDK
|