/*
 * Copyright 2017-2018 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 <chrono>
#include <string>

#include <gtest/gtest.h>
#include <rapidjson/document.h>

#include <AVSCommon/AVS/AbstractAVSConnectionManager.h>
#include <AVSCommon/AVS/Attachment/MockAttachmentManager.h>
#include <AVSCommon/SDKInterfaces/MockExceptionEncounteredSender.h>
#include <AVSCommon/SDKInterfaces/MockMessageSender.h>

#include "System/SoftwareInfoSender.h"

using namespace testing;

namespace alexaClientSDK {
namespace capabilityAgents {
namespace system {
namespace test {

using namespace avsCommon::avs;
using namespace avsCommon::avs::attachment;
using namespace avsCommon::avs::attachment::test;
using namespace avsCommon::utils;
using namespace avsCommon::sdkInterfaces;
using namespace avsCommon::sdkInterfaces::softwareInfo;
using namespace avsCommon::sdkInterfaces::test;

/// This is a string for the namespace we are testing for.
static const std::string NAMESPACE_SYSTEM = "System";

/// This is a string for the name of the System.SoftwareInfo event.
static const std::string NAME_SOFTWARE_INFO = "SoftwareInfo";

/// This is a string for the name of the System.ReportSoftwareInfo directive.
static const std::string NAME_REPORT_SOFTWARE_INFO = "ReportSoftwareInfo";

/// Dummy message ID with which to mock receiving a directive.
static const std::string MESSAGE_ID = "Message-1";

/// Empty dialogRequestId with which to mock receiving a directive.
static const std::string DIALOG_REQUEST_ID = "";

/// Dummy unparsed directive JSON.
static const std::string UNPARSED_DIRECTIVE = "";

/// Header of ReportSoftwareInfo directive.
static const auto REPORT_SOFTWARE_INFO_DIRECTIVE_HEADER =
    std::make_shared<AVSMessageHeader>(NAMESPACE_SYSTEM, NAME_REPORT_SOFTWARE_INFO, MESSAGE_ID, DIALOG_REQUEST_ID);

/// Dummy directive payload.
static const std::string TEST_PAYLOAD = "";

/// Empty attachment ID.
static const std::string ATTACHMENT_CONTEXT_ID = "";

/// Value for timeouts we expect to reach.
static const std::chrono::milliseconds EXPECTED_TIMEOUT(100);

/// Value for timeouts we do not expect to reach.
static const std::chrono::seconds UNEXPECTED_TIMEOUT(5);

/// Max time to wait for two send retries.
static const std::chrono::seconds TWO_RETRIES_TIMEOUT(15);

static const FirmwareVersion FIRST_FIRMWARE_VERSION = 1;
static const FirmwareVersion SECOND_FIRMWARE_VERSION = 2;
static const FirmwareVersion THIRD_FIRMWARE_VERSION = 3;

/**
 *
 */
class MockSoftwareInfoSenderObserver : public SoftwareInfoSenderObserverInterface {
public:
    MOCK_METHOD1(onFirmwareVersionAccepted, void(FirmwareVersion));
};

/**
 * Class with which to mock a connection ot AVS.
 */
class MockConnection : public AbstractAVSConnectionManager {
public:
    MockConnection();

    MOCK_METHOD0(enable, void());
    MOCK_METHOD0(disable, void());
    MOCK_METHOD0(isEnabled, bool());
    MOCK_METHOD0(reconnect, void());
    MOCK_METHOD1(
        addMessageObserver,
        void(std::shared_ptr<avsCommon::sdkInterfaces::MessageObserverInterface> observer));
    MOCK_METHOD1(
        removeMessageObserver,
        void(std::shared_ptr<avsCommon::sdkInterfaces::MessageObserverInterface> observer));

    bool isConnected() const;

    /**
     * Update the connection status.
     *
     * @param status The Connection Status.
     * @param reason The reason the Connection Status changed.
     */
    void updateConnectionStatus(
        ConnectionStatusObserverInterface::Status status,
        ConnectionStatusObserverInterface::ChangedReason reason);
};

MockConnection::MockConnection() : AbstractAVSConnectionManager{} {
}

bool MockConnection::isConnected() const {
    return ConnectionStatusObserverInterface::Status::CONNECTED == m_connectionStatus;
}

void MockConnection::updateConnectionStatus(
    ConnectionStatusObserverInterface::Status status,
    ConnectionStatusObserverInterface::ChangedReason reason) {
    AbstractAVSConnectionManager::updateConnectionStatus(status, reason);
}

/// Test harness for @c SoftwareInfoSender class.
class SoftwareInfoSenderTest : public ::testing::Test {
public:
    /// Set up the test harness for running a test.
    void SetUp() override;

protected:
    std::shared_ptr<StrictMock<MockSoftwareInfoSenderObserver>> m_mockObserver;
    /// Mocked connection
    std::shared_ptr<StrictMock<MockConnection>> m_mockConnection;
    /// Mocked MessageSenderInterface
    std::shared_ptr<StrictMock<MockMessageSender>> m_mockMessageSender;
    /// Mocked Exception Encountered Sender.
    std::shared_ptr<StrictMock<MockExceptionEncounteredSender>> m_mockExceptionEncounteredSender;
    /// Mock AttachmentManager for creating directives.
    std::shared_ptr<StrictMock<MockAttachmentManager>> m_mockAttachmentManager;
    /// System.ReportSoftwareInfo directive.
    std::shared_ptr<AVSDirective> m_reportSoftwareInfoDirective;
};

void SoftwareInfoSenderTest::SetUp() {
    m_mockObserver = std::make_shared<StrictMock<MockSoftwareInfoSenderObserver>>();
    m_mockConnection = std::make_shared<StrictMock<MockConnection>>();
    m_mockMessageSender = std::make_shared<StrictMock<MockMessageSender>>();
    m_mockExceptionEncounteredSender = std::make_shared<StrictMock<MockExceptionEncounteredSender>>();
    m_mockAttachmentManager = std::make_shared<StrictMock<MockAttachmentManager>>();
    m_reportSoftwareInfoDirective = AVSDirective::create(
        UNPARSED_DIRECTIVE,
        REPORT_SOFTWARE_INFO_DIRECTIVE_HEADER,
        TEST_PAYLOAD,
        m_mockAttachmentManager,
        ATTACHMENT_CONTEXT_ID);
}

/**
 * Verify that providing an invalid firmware version will cause SoftwareInfoSender::create() to fail.
 */
TEST_F(SoftwareInfoSenderTest, createFailedInvalidFirmwareVersion) {
    ASSERT_FALSE(SoftwareInfoSender::create(
        INVALID_FIRMWARE_VERSION,
        true,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender));
}

/**
 * Verify that passing false for sendSoftwareInfoUponConnect will NOT cause SoftwareInfoSender::create() to fail.
 */
TEST_F(SoftwareInfoSenderTest, createSuccessWithsendSoftwareInfoUponConnectFalse) {
    auto softwareInfoSender = SoftwareInfoSender::create(
        FIRST_FIRMWARE_VERSION,
        false,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);
    softwareInfoSender->shutdown();
}

/**
 * Verify that passing nullptr for observer will NOT cause SoftwareInfoSender::create() to fail.
 */
TEST_F(SoftwareInfoSenderTest, createSuccessWithObserverNull) {
    auto softwareInfoSender = SoftwareInfoSender::create(
        1, true, nullptr, m_mockConnection, m_mockMessageSender, m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);
    softwareInfoSender->shutdown();
}

/**
 * Verify that passing nullptr for connection will cause SoftwareInfoSender::create() to fail.
 */
TEST_F(SoftwareInfoSenderTest, createFailedConnectionNull) {
    ASSERT_FALSE(SoftwareInfoSender::create(
        1, true, m_mockObserver, nullptr, m_mockMessageSender, m_mockExceptionEncounteredSender));
}

/**
 * Verify that not providing a @c MessageSender will cause @c SoftwareInfoSender::create() to fail.
 */
TEST_F(SoftwareInfoSenderTest, createFailedMessageSenderNull) {
    ASSERT_FALSE(SoftwareInfoSender::create(
        1, true, m_mockObserver, m_mockConnection, nullptr, m_mockExceptionEncounteredSender));
}

/**
 * Verify that not providing a @c MessageSender will cause @c SoftwareInfoSender::create() to fail.
 */
TEST_F(SoftwareInfoSenderTest, createFailedExceptionEncounteredSenderNull) {
    ASSERT_FALSE(SoftwareInfoSender::create(1, true, m_mockObserver, m_mockConnection, m_mockMessageSender, nullptr));
}

/**
 * Verify that no SoftwareInfo event or ExceptionEncountered message is sent if @c sendSoftwareInfoOnConnect is
 * @c false and ReportSoftwareInfo directive is not received.
 */
TEST_F(SoftwareInfoSenderTest, noSoftwareInfoEventSentByDefault) {
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(_)).Times(0);
    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_)).Times(0);
    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        FIRST_FIRMWARE_VERSION,
        false,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::DISCONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    softwareInfoSender->shutdown();
}

/**
 * Verify that no attempt is made to send a SoftwareInfo event or and ExceptionEncounteredEvent if no connection
 * has been established - even if @c sendSoftwareInfoOnConnect is @c true.
 */
TEST_F(SoftwareInfoSenderTest, nothingSentBeforeConnected) {
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(_)).Times(0);
    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_)).Times(0);
    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        1, true, m_mockObserver, m_mockConnection, m_mockMessageSender, m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    softwareInfoSender->shutdown();
}

/**
 * Verify that one SoftwareInfo event is sent and no ExceptionEncountered message is sent if @c
 * sendSoftwareInfoOnConnect is @c true, a connection is made, and no ReportSoftwareInfo directive is received.
 */
TEST_F(SoftwareInfoSenderTest, softwareInfoSentUponConnectIfSendSetTrueBeforeConnect) {
    std::promise<void> versionAcceptedPromise;
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(_))
        .Times(1)
        .WillOnce(InvokeWithoutArgs([&versionAcceptedPromise]() { versionAcceptedPromise.set_value(); }));

    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_))
        .Times(1)
        .WillOnce(Invoke([](std::shared_ptr<avsCommon::avs::MessageRequest> request) {
            request->sendCompleted(MessageRequestObserverInterface::Status::SUCCESS_NO_CONTENT);
        }));

    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        1, true, m_mockObserver, m_mockConnection, m_mockMessageSender, m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);
    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::DISCONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    auto versionAcceptedFuture = versionAcceptedPromise.get_future();
    ASSERT_NE(versionAcceptedFuture.wait_for(UNEXPECTED_TIMEOUT), std::future_status::timeout);

    softwareInfoSender->shutdown();
}

/**
 * Verify that an event is sent if a @c ReportSoftwareInfo directive is received even if @c sendSoftwareInfoOnConnect is
 * @c false.
 */
TEST_F(SoftwareInfoSenderTest, reportSoftwareInfoReceived) {
    std::promise<void> versionAcceptedPromise;
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(_))
        .Times(1)
        .WillOnce(InvokeWithoutArgs([&versionAcceptedPromise]() { versionAcceptedPromise.set_value(); }));

    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_))
        .Times(1)
        .WillOnce(Invoke([](std::shared_ptr<avsCommon::avs::MessageRequest> request) {
            request->sendCompleted(MessageRequestObserverInterface::Status::SUCCESS_NO_CONTENT);
        }));

    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        FIRST_FIRMWARE_VERSION,
        false,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    softwareInfoSender->handleDirectiveImmediately(m_reportSoftwareInfoDirective);

    auto versionAcceptedFuture = versionAcceptedPromise.get_future();
    ASSERT_NE(versionAcceptedFuture.wait_for(UNEXPECTED_TIMEOUT), std::future_status::timeout);

    softwareInfoSender->shutdown();
}

/**
 * Verify that handling a @c ReportSoftwareInfo directive cancels incomplete handling of any previous
 * ReportSoftwareInfo directive.
 */
TEST_F(SoftwareInfoSenderTest, reportSoftwareInfoCancellsPreviousDirective) {
    // This status causes the first send request to retry, until set to something else.
    std::atomic<MessageRequestObserverInterface::Status> status(
        MessageRequestObserverInterface::Status::SERVER_INTERNAL_ERROR_V2);

    std::promise<void> versionAcceptedPromise;
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(_))
        .Times(1)
        .WillOnce(InvokeWithoutArgs([&versionAcceptedPromise]() { versionAcceptedPromise.set_value(); }));

    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_))
        .Times(2)
        .WillRepeatedly(Invoke([&status](std::shared_ptr<MessageRequest> request) {
            std::this_thread::sleep_for(EXPECTED_TIMEOUT);
            request->sendCompleted(status);
        }));

    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        FIRST_FIRMWARE_VERSION,
        false,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    softwareInfoSender->handleDirectiveImmediately(m_reportSoftwareInfoDirective);

    status = MessageRequestObserverInterface::Status::SUCCESS_NO_CONTENT;

    softwareInfoSender->handleDirectiveImmediately(m_reportSoftwareInfoDirective);

    // Sleep long enough for more than 2 sendMessage() calls to pile up.
    // Yes, it is weak to use a sleep to coordinate the timing of calls.  In
    // this case we are allowing time for calls that we do NOT expect to
    // happen (note that we EXPECT_CALL Time(2) above).  So, there is no
    // trigger we can use to know when to stop waiting.  If the timing
    // is not correct, this test will NOT generate false failures.
    std::this_thread::sleep_for(4 * EXPECTED_TIMEOUT);

    auto versionAcceptedFuture = versionAcceptedPromise.get_future();
    ASSERT_NE(versionAcceptedFuture.wait_for(UNEXPECTED_TIMEOUT), std::future_status::timeout);

    softwareInfoSender->shutdown();
}

/**
 * Verify that notification that the firmware version was accepted by @c AVS is only sent once.
 */
TEST_F(SoftwareInfoSenderTest, delayedReportSoftwareInfoNotifiesOnce) {
    std::promise<void> versionAcceptedPromise;
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(_))
        .Times(1)
        .WillOnce(InvokeWithoutArgs([&versionAcceptedPromise]() { versionAcceptedPromise.set_value(); }));

    std::promise<void> messageSentTwicePromise;
    int sentCounter = 0;
    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_))
        .Times(2)
        .WillRepeatedly(Invoke([&messageSentTwicePromise, &sentCounter](std::shared_ptr<MessageRequest> request) {
            request->sendCompleted(MessageRequestObserverInterface::Status::SUCCESS_NO_CONTENT);
            if (++sentCounter == 2) {
                messageSentTwicePromise.set_value();
            }
        }));

    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        FIRST_FIRMWARE_VERSION,
        false,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    softwareInfoSender->handleDirectiveImmediately(m_reportSoftwareInfoDirective);

    auto versionAcceptedFuture = versionAcceptedPromise.get_future();
    ASSERT_NE(versionAcceptedFuture.wait_for(UNEXPECTED_TIMEOUT), std::future_status::timeout);

    softwareInfoSender->handleDirectiveImmediately(m_reportSoftwareInfoDirective);

    auto messageSentTwiceFuture = messageSentTwicePromise.get_future();
    ASSERT_NE(messageSentTwiceFuture.wait_for(UNEXPECTED_TIMEOUT), std::future_status::timeout);

    softwareInfoSender->shutdown();
}

/**
 * Verify that SoftwareInfoSender retries sending.
 */
TEST_F(SoftwareInfoSenderTest, verifySendRetries) {
    std::promise<void> versionAcceptedPromise;
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(_))
        .Times(1)
        .WillOnce(InvokeWithoutArgs([&versionAcceptedPromise]() { versionAcceptedPromise.set_value(); }));

    int callCount = 0;
    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_))
        .Times(3)
        .WillRepeatedly(Invoke([&callCount](std::shared_ptr<MessageRequest> request) {
            request->sendCompleted(
                ++callCount == 3 ? MessageRequestObserverInterface::Status::SUCCESS_NO_CONTENT
                                 : MessageRequestObserverInterface::Status::SERVER_INTERNAL_ERROR_V2);
        }));

    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        1, true, m_mockObserver, m_mockConnection, m_mockMessageSender, m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    auto versionAcceptedFuture = versionAcceptedPromise.get_future();
    ASSERT_NE(versionAcceptedFuture.wait_for(TWO_RETRIES_TIMEOUT), std::future_status::timeout);

    softwareInfoSender->shutdown();
}

/**
 * Verify that attempting to set an invalid firmware version fails.
 */
TEST_F(SoftwareInfoSenderTest, setInvalidFirmwareVersion) {
    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_)).Times(0);
    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        FIRST_FIRMWARE_VERSION,
        false,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    ASSERT_FALSE(softwareInfoSender->setFirmwareVersion(INVALID_FIRMWARE_VERSION));

    softwareInfoSender->shutdown();
}

/**
 * Verify that handling a @c ReportSoftwareInfo directive cancels incomplete handling of any previous
 * ReportSoftwareInfo directive.
 */
TEST_F(SoftwareInfoSenderTest, setFirmwareVersionCancellsPreviousSetting) {
    // This status causes the first send request to retry, until set to something else.
    std::atomic<MessageRequestObserverInterface::Status> status(
        MessageRequestObserverInterface::Status::SERVER_INTERNAL_ERROR_V2);

    std::promise<void> versionAcceptedPromise;
    EXPECT_CALL(*(m_mockObserver.get()), onFirmwareVersionAccepted(THIRD_FIRMWARE_VERSION))
        .Times(1)
        .WillOnce(InvokeWithoutArgs([&versionAcceptedPromise]() { versionAcceptedPromise.set_value(); }));

    EXPECT_CALL(*(m_mockMessageSender.get()), sendMessage(_))
        .Times(2)
        .WillRepeatedly(Invoke([&status](std::shared_ptr<MessageRequest> request) {
            std::this_thread::sleep_for(EXPECTED_TIMEOUT);
            request->sendCompleted(status);
        }));

    EXPECT_CALL(*(m_mockExceptionEncounteredSender.get()), sendExceptionEncountered(_, _, _)).Times(0);

    auto softwareInfoSender = SoftwareInfoSender::create(
        FIRST_FIRMWARE_VERSION,
        false,
        m_mockObserver,
        m_mockConnection,
        m_mockMessageSender,
        m_mockExceptionEncounteredSender);
    ASSERT_TRUE(softwareInfoSender);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::PENDING,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    m_mockConnection->updateConnectionStatus(
        ConnectionStatusObserverInterface::Status::CONNECTED,
        ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST);

    softwareInfoSender->setFirmwareVersion(SECOND_FIRMWARE_VERSION);

    status = MessageRequestObserverInterface::Status::SUCCESS_NO_CONTENT;

    softwareInfoSender->setFirmwareVersion(THIRD_FIRMWARE_VERSION);

    // Sleep long enough for more than 2 sendMessage() calls to pile up.
    // Yes, it is weak to use a sleep to coordinate the timing of calls.  In
    // this case we are allowing time for calls that we do NOT expect to
    // happen (note the EXPECT_CALL Time(2) above).  So, there is no
    // trigger we can use to know when to stop waiting.  If the timing
    // is not correct, this test will NOT generate false failures.
    std::this_thread::sleep_for(4 * EXPECTED_TIMEOUT);

    auto versionAcceptedFuture = versionAcceptedPromise.get_future();
    ASSERT_NE(versionAcceptedFuture.wait_for(UNEXPECTED_TIMEOUT), std::future_status::timeout);

    softwareInfoSender->shutdown();
}

}  // namespace test
}  // namespace system
}  // namespace capabilityAgents
}  // namespace alexaClientSDK