958 lines
36 KiB
C++
958 lines
36 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 <gtest/gtest.h>
|
|
#include <gmock/gmock.h>
|
|
#include <gmock/gmock-actions.h>
|
|
|
|
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
|
|
#include <AVSCommon/Utils/Metrics/MockMetricRecorder.h>
|
|
#include <AVSCommon/Utils/Timing/TimeUtils.h>
|
|
#include <RegistrationManager/CustomerDataManager.h>
|
|
#include <Settings/DeviceSettingsManager.h>
|
|
|
|
#include "acsdkAlerts/AlertScheduler.h"
|
|
|
|
namespace alexaClientSDK {
|
|
namespace acsdkAlerts {
|
|
namespace test {
|
|
|
|
using namespace acsdkAlertsInterfaces;
|
|
using namespace testing;
|
|
|
|
/// Tokens for alerts.
|
|
static const std::string ALERT1_TOKEN = "token1";
|
|
static const std::string ALERT2_TOKEN = "token2";
|
|
static const std::string ALERT3_TOKEN = "token3";
|
|
static const std::string ALERT4_TOKEN = "token4";
|
|
|
|
/// Test alert type
|
|
static const std::string ALERT_TYPE = "TEST_ALERT_TYPE";
|
|
|
|
/// A schedule instant in the past for alerts.
|
|
static const std::string PAST_INSTANT = "2000-01-01T12:34:56+0000";
|
|
|
|
/// A schedule instant in the future for alerts.
|
|
static const std::string FUTURE_INSTANT_SUFFIX = "-01-01T12:34:56+0000";
|
|
|
|
/// Amount of time that the alert observer should wait for a task to finish.
|
|
static const std::chrono::milliseconds TEST_TIMEOUT{100};
|
|
|
|
/// Alert past due time limit.
|
|
static const std::chrono::seconds ALERT_PAST_DUE_TIME_LIMIT{10};
|
|
|
|
class MockRenderer : public renderer::RendererInterface {
|
|
public:
|
|
MOCK_METHOD7(
|
|
start,
|
|
void(
|
|
std::shared_ptr<acsdkAlerts::renderer::RendererObserverInterface> observer,
|
|
std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()> audioFactory,
|
|
bool alarmVolumeRampEnabled,
|
|
const std::vector<std::string>& urls,
|
|
int loopCount,
|
|
std::chrono::milliseconds loopPause,
|
|
bool startWithPause));
|
|
MOCK_METHOD0(stop, void());
|
|
};
|
|
|
|
class TestAlert : public Alert {
|
|
public:
|
|
TestAlert() :
|
|
Alert(defaultAudioFactory, shortAudioFactory, nullptr),
|
|
m_alertType{ALERT_TYPE},
|
|
m_renderer{std::make_shared<MockRenderer>()} {
|
|
this->setRenderer(m_renderer);
|
|
}
|
|
|
|
TestAlert(const std::string& token, const std::string& schedTime) :
|
|
Alert(defaultAudioFactory, shortAudioFactory, nullptr),
|
|
m_alertType{ALERT_TYPE},
|
|
m_renderer{std::make_shared<MockRenderer>()} {
|
|
this->setRenderer(m_renderer);
|
|
|
|
// clang-format off
|
|
const std::string payloadJson =
|
|
"{"
|
|
"\"token\": \"" + token + "\","
|
|
"\"type\": \"" + m_alertType + "\","
|
|
"\"scheduledTime\": \"" + schedTime + "\""
|
|
"}";
|
|
// clang-format on
|
|
|
|
std::string errorMessage;
|
|
rapidjson::Document payload;
|
|
payload.Parse(payloadJson);
|
|
|
|
this->parseFromJson(payload, &errorMessage);
|
|
}
|
|
|
|
std::string getTypeName() const override {
|
|
return m_alertType;
|
|
}
|
|
|
|
private:
|
|
static std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType> defaultAudioFactory() {
|
|
return std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>(
|
|
std::unique_ptr<std::stringstream>(new std::stringstream("default audio")),
|
|
avsCommon::utils::MediaType::MPEG);
|
|
}
|
|
|
|
static std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType> shortAudioFactory() {
|
|
return std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>(
|
|
std::unique_ptr<std::stringstream>(new std::stringstream("short audio")),
|
|
avsCommon::utils::MediaType::MPEG);
|
|
}
|
|
|
|
const std::string m_alertType;
|
|
std::shared_ptr<MockRenderer> m_renderer;
|
|
};
|
|
|
|
class MockAlertStorage : public storage::AlertStorageInterface {
|
|
public:
|
|
MockAlertStorage() {
|
|
m_createDatabaseRetVal = true;
|
|
m_openRetVal = true;
|
|
m_isOpenRetVal = true;
|
|
m_alertExistsRetVal = true;
|
|
m_storeRetVal = true;
|
|
m_loadRetVal = true;
|
|
m_eraseRetVal = true;
|
|
}
|
|
|
|
bool createDatabase() {
|
|
return m_createDatabaseRetVal;
|
|
}
|
|
bool open() {
|
|
return m_openRetVal;
|
|
}
|
|
bool isOpen() {
|
|
return m_isOpenRetVal;
|
|
}
|
|
void close() {
|
|
}
|
|
bool alertExists(const std::string& token) {
|
|
return m_alertExistsRetVal;
|
|
}
|
|
bool store(std::shared_ptr<Alert> alert) {
|
|
return m_storeRetVal;
|
|
}
|
|
bool load(
|
|
std::vector<std::shared_ptr<Alert>>* alertContainer,
|
|
std::shared_ptr<settings::DeviceSettingsManager> settingsManager) {
|
|
if (m_loadRetVal) {
|
|
alertContainer->clear();
|
|
for (std::shared_ptr<Alert> alertToAdd : m_alertsInStorage) {
|
|
alertContainer->push_back(alertToAdd);
|
|
}
|
|
}
|
|
return m_loadRetVal;
|
|
}
|
|
bool erase(const std::vector<int>& alertDbIds) {
|
|
return m_eraseRetVal;
|
|
}
|
|
void setCreateDatabaseRetVal(bool retVal) {
|
|
m_createDatabaseRetVal = retVal;
|
|
}
|
|
void setOpenRetVal(bool retVal) {
|
|
m_openRetVal = retVal;
|
|
}
|
|
void setIsOpenRetVal(bool retVal) {
|
|
m_isOpenRetVal = retVal;
|
|
}
|
|
void setAlertExistsRetVal(bool retVal) {
|
|
m_alertExistsRetVal = retVal;
|
|
}
|
|
void setStoreRetVal(bool retVal) {
|
|
m_storeRetVal = retVal;
|
|
}
|
|
void setLoadRetVal(bool retVal) {
|
|
m_loadRetVal = retVal;
|
|
}
|
|
void setEraseRetVal(bool retVal) {
|
|
m_eraseRetVal = retVal;
|
|
}
|
|
void setAlerts(std::vector<std::shared_ptr<TestAlert>> alertsToAdd) {
|
|
m_alertsInStorage.clear();
|
|
for (std::shared_ptr<TestAlert> alertToAdd : alertsToAdd) {
|
|
m_alertsInStorage.push_back(alertToAdd);
|
|
}
|
|
}
|
|
|
|
MOCK_METHOD1(bulkErase, bool(const std::list<std::shared_ptr<Alert>>&));
|
|
MOCK_METHOD1(erase, bool(std::shared_ptr<Alert>));
|
|
MOCK_METHOD1(modify, bool(std::shared_ptr<Alert>));
|
|
MOCK_METHOD0(clearDatabase, bool());
|
|
|
|
private:
|
|
std::vector<std::shared_ptr<Alert>> m_alertsInStorage;
|
|
bool m_createDatabaseRetVal;
|
|
bool m_openRetVal;
|
|
bool m_isOpenRetVal;
|
|
bool m_alertExistsRetVal;
|
|
bool m_storeRetVal;
|
|
bool m_loadRetVal;
|
|
bool m_eraseRetVal;
|
|
};
|
|
|
|
class TestAlertObserver : public AlertObserverInterface {
|
|
public:
|
|
bool waitFor(AlertScheduler::State newState) {
|
|
std::unique_lock<std::mutex> lock(m_mutex);
|
|
return m_conditionVariable.wait_for(lock, TEST_TIMEOUT, [this, newState] { return m_state == newState; });
|
|
}
|
|
|
|
void onAlertStateChange(
|
|
const std::string& alertToken,
|
|
const std::string& alertType,
|
|
AlertScheduler::State newState,
|
|
const std::string& reason) {
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
|
m_state = newState;
|
|
m_conditionVariable.notify_all();
|
|
}
|
|
|
|
private:
|
|
std::mutex m_mutex;
|
|
std::condition_variable m_conditionVariable;
|
|
AlertScheduler::State m_state;
|
|
};
|
|
|
|
class AlertSchedulerTest : public ::testing::Test {
|
|
public:
|
|
AlertSchedulerTest();
|
|
void SetUp() override;
|
|
std::shared_ptr<TestAlert> doSimpleTestSetup(bool activateAlert = false, bool initWithAlertObserver = false);
|
|
|
|
protected:
|
|
std::shared_ptr<MockAlertStorage> m_alertStorage;
|
|
std::shared_ptr<MockRenderer> m_alertRenderer;
|
|
std::chrono::seconds m_alertPastDueTimeLimit;
|
|
std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> m_metricRecorder;
|
|
std::shared_ptr<AlertScheduler> m_alertScheduler;
|
|
std::shared_ptr<TestAlertObserver> m_testAlertObserver;
|
|
std::shared_ptr<settings::DeviceSettingsManager> m_settingsManager;
|
|
};
|
|
|
|
static std::string getFutureInstant(int yearsPlus) {
|
|
std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
|
|
time_t tt = std::chrono::system_clock::to_time_t(now);
|
|
tm utc_tm = *gmtime(&tt);
|
|
return std::to_string(utc_tm.tm_year + 1900 + yearsPlus) + FUTURE_INSTANT_SUFFIX;
|
|
}
|
|
|
|
static std::string getTimeNow() {
|
|
std::string timeNowStr;
|
|
auto timeNow = std::chrono::system_clock::now();
|
|
avsCommon::utils::timing::TimeUtils().convertTimeToUtcIso8601Rfc3339(timeNow, &timeNowStr);
|
|
return timeNowStr;
|
|
}
|
|
|
|
AlertSchedulerTest::AlertSchedulerTest() :
|
|
m_alertStorage{std::make_shared<MockAlertStorage>()},
|
|
m_alertRenderer{std::make_shared<MockRenderer>()},
|
|
m_alertPastDueTimeLimit{ALERT_PAST_DUE_TIME_LIMIT},
|
|
m_metricRecorder{std::make_shared<NiceMock<avsCommon::utils::metrics::test::MockMetricRecorder>>()},
|
|
m_alertScheduler{std::make_shared<AlertScheduler>(
|
|
m_alertStorage,
|
|
m_alertRenderer,
|
|
m_alertPastDueTimeLimit,
|
|
m_metricRecorder)},
|
|
m_testAlertObserver{std::make_shared<TestAlertObserver>()} {
|
|
}
|
|
|
|
void AlertSchedulerTest::SetUp() {
|
|
m_alertStorage->setOpenRetVal(true);
|
|
m_settingsManager =
|
|
std::make_shared<settings::DeviceSettingsManager>(std::make_shared<registrationManager::CustomerDataManager>());
|
|
}
|
|
|
|
/**
|
|
* Helper method that does a basic setup for tests.
|
|
* The method performs the following functions:
|
|
* 1 - Creates a test alert and adds it to be scheduled
|
|
* 2 - If initializing with alert scheduler observer, then creates alert scheduler observer
|
|
* 3 - Initializes the alert scheduler
|
|
* 4 - Based on the argument, may initialize the alert
|
|
*
|
|
* The method will return the scheduled alert
|
|
*/
|
|
std::shared_ptr<TestAlert> AlertSchedulerTest::doSimpleTestSetup(bool activateAlert, bool initWithAlertObserver) {
|
|
std::vector<std::shared_ptr<TestAlert>> alertToAdd;
|
|
std::shared_ptr<TestAlert> alert = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
alertToAdd.push_back(alert);
|
|
m_alertStorage->setAlerts(alertToAdd);
|
|
|
|
if (initWithAlertObserver) {
|
|
m_alertScheduler->initialize(m_testAlertObserver, m_settingsManager);
|
|
;
|
|
} else {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{std::make_shared<AlertScheduler>(
|
|
m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
}
|
|
|
|
if (activateAlert) {
|
|
alert->activate();
|
|
m_alertScheduler->updateFocus(avsCommon::avs::FocusState::BACKGROUND);
|
|
}
|
|
|
|
return alert;
|
|
}
|
|
|
|
/**
|
|
* Test initializing AlertScheduler
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_initialize) {
|
|
/// check if init fails if scheduler is not available
|
|
ASSERT_FALSE(m_alertScheduler->initialize(nullptr, nullptr));
|
|
ASSERT_FALSE(m_alertScheduler->initialize(nullptr, m_settingsManager));
|
|
|
|
/// check if init fails if a database for alerts cant be created
|
|
m_alertStorage->setOpenRetVal(false);
|
|
m_alertStorage->setCreateDatabaseRetVal(false);
|
|
ASSERT_FALSE(m_alertScheduler->initialize(m_alertScheduler, m_settingsManager));
|
|
|
|
/// check if init succeeds.
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
m_alertStorage->setOpenRetVal(true);
|
|
|
|
ASSERT_TRUE(m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager, false));
|
|
}
|
|
|
|
/**
|
|
* Test AlertScheduler getting focus
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_updateGetFocus) {
|
|
std::shared_ptr<TestAlert> alert = doSimpleTestSetup();
|
|
|
|
// check if focus changes to foreground
|
|
m_alertScheduler->updateFocus(avsCommon::avs::FocusState::FOREGROUND);
|
|
ASSERT_EQ(m_alertScheduler->getFocusState(), avsCommon::avs::FocusState::FOREGROUND);
|
|
|
|
// check if focus changes to background
|
|
m_alertScheduler->updateFocus(avsCommon::avs::FocusState::BACKGROUND);
|
|
ASSERT_EQ(m_alertScheduler->getFocusState(), avsCommon::avs::FocusState::BACKGROUND);
|
|
|
|
// check alert state change if focus is gone
|
|
m_alertScheduler->updateFocus(avsCommon::avs::FocusState::NONE);
|
|
ASSERT_EQ(alert->getState(), Alert::State::STOPPING);
|
|
}
|
|
|
|
/**
|
|
* Test scheduling alerts
|
|
*/
|
|
TEST_F(AlertSchedulerTest, DISABLED_test_scheduleAlert) {
|
|
// check that a future alert is scheduled
|
|
std::shared_ptr<TestAlert> alert1 = doSimpleTestSetup(true);
|
|
ASSERT_TRUE(m_alertScheduler->scheduleAlert(alert1));
|
|
|
|
// check that a future alert is not scheduled if you cant store the alert
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(1));
|
|
m_alertStorage->setStoreRetVal(false);
|
|
ASSERT_FALSE(m_alertScheduler->scheduleAlert(alert2));
|
|
|
|
// check that past alerts cant be scheduled
|
|
std::shared_ptr<TestAlert> alert3 = std::make_shared<TestAlert>(ALERT3_TOKEN, PAST_INSTANT);
|
|
m_alertStorage->setStoreRetVal(true);
|
|
ASSERT_TRUE(m_alertScheduler->scheduleAlert(alert2));
|
|
ASSERT_FALSE(m_alertScheduler->scheduleAlert(alert3));
|
|
}
|
|
|
|
/**
|
|
* Test reloading alerts from the database and simultaneously scheduling them.
|
|
*/
|
|
TEST_F(AlertSchedulerTest, DISABLED_test_reloadAlertsFromDatabaseWithScheduling) {
|
|
/// check if reload with shouldScheduleAlerts set to true succeeds. Pass in 3 alerts of which 1 is expired. Only 2
|
|
/// should actually remain in the end.
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
m_alertStorage->setOpenRetVal(true);
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
|
|
/// initialize the alert scheduler
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager, false);
|
|
|
|
/// past alert
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, PAST_INSTANT);
|
|
alertsToAdd.push_back(alert1);
|
|
|
|
/// future active alert
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(1));
|
|
alert2->activate();
|
|
alert2->setStateActive();
|
|
alertsToAdd.push_back(alert2);
|
|
|
|
/// future inactive alert
|
|
std::shared_ptr<TestAlert> alert3 = std::make_shared<TestAlert>(ALERT3_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert3);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
|
|
/// past alert should get removed
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(1);
|
|
|
|
/// active alert should get modified
|
|
EXPECT_CALL(*(m_alertStorage.get()), modify(testing::_)).Times(1);
|
|
|
|
const bool shouldScheduleAlerts = true;
|
|
|
|
ASSERT_TRUE(m_alertScheduler->reloadAlertsFromDatabase(m_settingsManager, shouldScheduleAlerts));
|
|
|
|
const unsigned int expectedRemainingAlerts = 2;
|
|
|
|
/// only the 2 future alerts remain
|
|
ASSERT_EQ(m_alertScheduler->getContextInfo().scheduledAlerts.size(), expectedRemainingAlerts);
|
|
}
|
|
|
|
/**
|
|
* Test reloading alerts from the database without scheduling.
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_reloadAlertsFromDatabaseWithoutScheduling) {
|
|
/// check if reload with shouldScheduleAlerts set to false succeeds. Pass in 3 alerts of which 1 is expired. All
|
|
/// alerts should remain in the end.
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
m_alertStorage->setOpenRetVal(true);
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
|
|
/// initialize the alert scheduler
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager, false);
|
|
|
|
/// past alert
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, PAST_INSTANT);
|
|
alertsToAdd.push_back(alert1);
|
|
|
|
/// future active alert
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(1));
|
|
alert2->activate();
|
|
alert2->setStateActive();
|
|
alertsToAdd.push_back(alert2);
|
|
|
|
/// future inactive alert
|
|
std::shared_ptr<TestAlert> alert3 = std::make_shared<TestAlert>(ALERT3_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert3);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
|
|
/// no alerts should be modified or erased
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(0);
|
|
EXPECT_CALL(*(m_alertStorage.get()), modify(testing::_)).Times(0);
|
|
|
|
const bool shouldScheduleAlerts = false;
|
|
|
|
ASSERT_TRUE(m_alertScheduler->reloadAlertsFromDatabase(m_settingsManager, shouldScheduleAlerts));
|
|
|
|
const unsigned int expectedRemainingAlerts = 3;
|
|
|
|
/// all alerts should remain
|
|
ASSERT_EQ(m_alertScheduler->getContextInfo().scheduledAlerts.size(), expectedRemainingAlerts);
|
|
}
|
|
|
|
/**
|
|
* Test update alert scheduled time.
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_updateAlertTime) {
|
|
// Schedule an alert and create an updated version with the same token.
|
|
auto oldAlert = doSimpleTestSetup();
|
|
auto newAlert = std::make_shared<TestAlert>(oldAlert->getToken(), getFutureInstant(2));
|
|
|
|
ASSERT_NE(oldAlert->getScheduledTime_ISO_8601(), newAlert->getScheduledTime_ISO_8601());
|
|
|
|
// Expect database to be updated with new schedule.
|
|
EXPECT_CALL(*m_alertStorage, modify(_)).WillOnce(Return(true));
|
|
|
|
// Call schedule alert for an alert that already exists.
|
|
EXPECT_TRUE(m_alertScheduler->scheduleAlert(newAlert));
|
|
ASSERT_EQ(oldAlert->getScheduledTime_ISO_8601(), newAlert->getScheduledTime_ISO_8601());
|
|
}
|
|
|
|
/**
|
|
* Test update alert for new assets.
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_updateAlertAssets) {
|
|
// Schedule an alert and create an updated verision with the same token.
|
|
auto oldAlert = doSimpleTestSetup();
|
|
|
|
auto newAlert = std::make_shared<TestAlert>(oldAlert->getToken(), oldAlert->getScheduledTime_ISO_8601());
|
|
ASSERT_EQ(oldAlert->getScheduledTime_ISO_8601(), newAlert->getScheduledTime_ISO_8601());
|
|
|
|
// Create assets for Alert.
|
|
std::unordered_map<std::string, Alert::Asset> assets;
|
|
assets["A"] = Alert::Asset("A", "http://test.com/a");
|
|
assets["B"] = Alert::Asset("B", "http://test.com/a");
|
|
|
|
std::vector<std::string> playOrderItems;
|
|
playOrderItems.push_back("A");
|
|
playOrderItems.push_back("B");
|
|
|
|
Alert::AssetConfiguration c;
|
|
c.assets = assets;
|
|
c.assetPlayOrderItems = playOrderItems;
|
|
c.backgroundAssetId = "A";
|
|
c.loopPause = std::chrono::milliseconds(100);
|
|
|
|
// Assign assets to the new alert.
|
|
ASSERT_TRUE(newAlert->setAssetConfiguration(c));
|
|
|
|
// Expect database to be updated with new schedule.
|
|
EXPECT_CALL(*m_alertStorage, modify(_)).WillOnce(Return(true));
|
|
|
|
// Call schedule alert for an alert that already exists.
|
|
EXPECT_TRUE(m_alertScheduler->scheduleAlert(newAlert));
|
|
ASSERT_EQ(oldAlert->getScheduledTime_ISO_8601(), newAlert->getScheduledTime_ISO_8601());
|
|
|
|
// Check assets were assigned correctly.
|
|
Alert::AssetConfiguration oldAlertAssets = oldAlert->getAssetConfiguration();
|
|
Alert::AssetConfiguration newAlertAssets = newAlert->getAssetConfiguration();
|
|
ASSERT_EQ(oldAlertAssets.assets.size(), newAlertAssets.assets.size());
|
|
ASSERT_EQ(oldAlertAssets.assets["A"].id, newAlertAssets.assets["A"].id);
|
|
ASSERT_EQ(oldAlertAssets.assets["A"].url, newAlertAssets.assets["A"].url);
|
|
ASSERT_EQ(oldAlertAssets.assets["B"].id, newAlertAssets.assets["B"].id);
|
|
ASSERT_EQ(oldAlertAssets.assets["B"].url, newAlertAssets.assets["B"].url);
|
|
|
|
ASSERT_EQ(oldAlertAssets.assetPlayOrderItems, newAlertAssets.assetPlayOrderItems);
|
|
ASSERT_EQ(oldAlertAssets.backgroundAssetId, newAlertAssets.backgroundAssetId);
|
|
ASSERT_EQ(oldAlertAssets.loopPause, newAlertAssets.loopPause);
|
|
}
|
|
|
|
/**
|
|
* Test update alert scheduled time to now will start rendering the alert.
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_rescheduleAlertNow) {
|
|
// Schedule an alert and create an updated version with the same token.
|
|
auto oldAlert = doSimpleTestSetup(/*activeAlert*/ false, /*initWithAlertObserver*/ true);
|
|
auto newAlert = std::make_shared<TestAlert>(oldAlert->getToken(), getTimeNow());
|
|
ASSERT_NE(oldAlert->getScheduledTime_ISO_8601(), newAlert->getScheduledTime_ISO_8601());
|
|
|
|
// Expect database to be updated with new schedule.
|
|
EXPECT_CALL(*m_alertStorage, modify(_)).WillOnce(Return(true));
|
|
|
|
// Call schedule alert for an alert that already exists.
|
|
EXPECT_TRUE(m_alertScheduler->scheduleAlert(newAlert));
|
|
ASSERT_EQ(oldAlert->getScheduledTime_ISO_8601(), newAlert->getScheduledTime_ISO_8601());
|
|
|
|
// Wait till alarm is ready to be rendered.
|
|
EXPECT_TRUE(m_testAlertObserver->waitFor(AlertObserverInterface::State::READY));
|
|
}
|
|
|
|
/**
|
|
* Test update alert scheduled time fails.
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_rescheduleAlertFails) {
|
|
// Schedule an alert and create an updated version with the same token.
|
|
auto oldAlert = doSimpleTestSetup();
|
|
auto newAlert = std::make_shared<TestAlert>(oldAlert->getToken(), getFutureInstant(2));
|
|
auto oldScheduledTime = oldAlert->getScheduledTime_ISO_8601();
|
|
ASSERT_NE(newAlert->getScheduledTime_ISO_8601(), oldScheduledTime);
|
|
|
|
// Simulate database failure.
|
|
EXPECT_CALL(*m_alertStorage, modify(_)).WillOnce(Return(false));
|
|
|
|
// Call schedule alert for an alert that already exists.
|
|
EXPECT_FALSE(m_alertScheduler->scheduleAlert(newAlert));
|
|
EXPECT_EQ(oldAlert->getScheduledTime_ISO_8601(), oldScheduledTime);
|
|
}
|
|
|
|
/**
|
|
* Test snoozing alerts
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_snoozeAlert) {
|
|
doSimpleTestSetup(true);
|
|
|
|
// check that a random alert token is ignored
|
|
ASSERT_FALSE(m_alertScheduler->snoozeAlert(ALERT2_TOKEN, getFutureInstant(1)));
|
|
|
|
// check that we succeed if the correct token is available
|
|
ASSERT_TRUE(m_alertScheduler->snoozeAlert(ALERT1_TOKEN, getFutureInstant(1)));
|
|
}
|
|
|
|
/**
|
|
* Test deleting single alert
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_deleteAlertSingle) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert1);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
m_alertScheduler->updateFocus(avsCommon::avs::FocusState::BACKGROUND);
|
|
|
|
// if active alert and the token matches, ensure that we dont delete it (we deactivate the alert actually)
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(0);
|
|
ASSERT_TRUE(m_alertScheduler->deleteAlert(ALERT1_TOKEN));
|
|
|
|
// check that a random alert token is ignored
|
|
ASSERT_TRUE(m_alertScheduler->deleteAlert(ALERT2_TOKEN));
|
|
|
|
// if inactive alert, then check that we succeed if the correct token is available
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(1);
|
|
ASSERT_TRUE(m_alertScheduler->deleteAlert(ALERT2_TOKEN));
|
|
}
|
|
|
|
/**
|
|
* Test deleting multiple alerts - one at a time
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_bulkDeleteAlertsSingle) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(2));
|
|
|
|
ON_CALL(*m_alertStorage.get(), bulkErase(_)).WillByDefault(Return(true));
|
|
|
|
alertsToAdd.push_back(alert1);
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
|
|
// Delete one existing
|
|
ASSERT_EQ(m_alertScheduler->getAllAlerts().size(), 2u);
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({ALERT1_TOKEN}));
|
|
ASSERT_EQ(m_alertScheduler->getAllAlerts().size(), 1u);
|
|
|
|
// Delete one non-existing
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({ALERT3_TOKEN}));
|
|
ASSERT_EQ(m_alertScheduler->getAllAlerts().size(), 1u);
|
|
|
|
// Delete the last existing
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({ALERT2_TOKEN}));
|
|
ASSERT_EQ(m_alertScheduler->getAllAlerts().size(), 0u);
|
|
}
|
|
|
|
/**
|
|
* Test deleting multiple existing alerts
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_bulkDeleteAlertsMultipleExisting) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(2));
|
|
|
|
ON_CALL(*m_alertStorage.get(), bulkErase(_)).WillByDefault(Return(true));
|
|
|
|
alertsToAdd.push_back(alert1);
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
|
|
// Delete multiple existing
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({ALERT1_TOKEN, ALERT2_TOKEN}));
|
|
EXPECT_EQ(m_alertScheduler->getAllAlerts().size(), 0u);
|
|
}
|
|
|
|
/**
|
|
* Test deleting multiple alerts, both existing and not
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_bulkDeleteAlertsMultipleMixed) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(2));
|
|
|
|
ON_CALL(*m_alertStorage.get(), bulkErase(_)).WillByDefault(Return(true));
|
|
|
|
alertsToAdd.push_back(alert1);
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
|
|
// Delete multiple mixed
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({ALERT1_TOKEN, ALERT3_TOKEN}));
|
|
EXPECT_EQ(m_alertScheduler->getAllAlerts().size(), 1u);
|
|
}
|
|
|
|
/**
|
|
* Test deleting multiple non-existing alerts
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_bulkDeleteAlertsMultipleMissing) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(2));
|
|
|
|
ON_CALL(*m_alertStorage.get(), bulkErase(_)).WillByDefault(Return(true));
|
|
|
|
alertsToAdd.push_back(alert1);
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
|
|
// Delete multiple non-existing
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({ALERT3_TOKEN, ALERT4_TOKEN}));
|
|
EXPECT_EQ(m_alertScheduler->getAllAlerts().size(), 2u);
|
|
}
|
|
|
|
/**
|
|
* Test deleting same alerts multiple times
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_bulkDeleteAlertsMultipleSame) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(2));
|
|
|
|
ON_CALL(*m_alertStorage.get(), bulkErase(_)).WillByDefault(Return(true));
|
|
|
|
alertsToAdd.push_back(alert1);
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
|
|
// Delete same multiple times
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({ALERT1_TOKEN, ALERT1_TOKEN}));
|
|
EXPECT_EQ(m_alertScheduler->getAllAlerts().size(), 1u);
|
|
}
|
|
|
|
/**
|
|
* Test bulk deleting with empty list
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_bulkDeleteAlertsMultipleEmpty) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(2));
|
|
|
|
ON_CALL(*m_alertStorage.get(), bulkErase(_)).WillByDefault(Return(true));
|
|
|
|
alertsToAdd.push_back(alert1);
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
|
|
// Delete empty
|
|
EXPECT_TRUE(m_alertScheduler->deleteAlerts({}));
|
|
EXPECT_EQ(m_alertScheduler->getAllAlerts().size(), 2u);
|
|
}
|
|
|
|
/**
|
|
* Test method that checks if an alert is active
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_isAlertActive) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
|
|
/// active alert
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert1);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
m_alertScheduler->updateFocus(avsCommon::avs::FocusState::BACKGROUND);
|
|
|
|
/// inactive alert
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
|
|
/// Success expected for active alert
|
|
ASSERT_TRUE(m_alertScheduler->isAlertActive(alert1));
|
|
|
|
/// Failure expected for inactive alert
|
|
ASSERT_FALSE(m_alertScheduler->isAlertActive(alert2));
|
|
}
|
|
|
|
/**
|
|
* Test to see if the correct context about the scheduler is obtained
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_getContextInfo) {
|
|
std::shared_ptr<AlertScheduler> alertSchedulerObs{
|
|
std::make_shared<AlertScheduler>(m_alertStorage, m_alertRenderer, m_alertPastDueTimeLimit, m_metricRecorder)};
|
|
std::vector<std::shared_ptr<TestAlert>> alertsToAdd;
|
|
|
|
/// Schedule 2 alerts one of which is active.
|
|
std::shared_ptr<TestAlert> alert1 = std::make_shared<TestAlert>(ALERT1_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert1);
|
|
std::shared_ptr<TestAlert> alert2 = std::make_shared<TestAlert>(ALERT2_TOKEN, getFutureInstant(1));
|
|
alertsToAdd.push_back(alert2);
|
|
m_alertStorage->setAlerts(alertsToAdd);
|
|
m_alertScheduler->initialize(alertSchedulerObs, m_settingsManager);
|
|
m_alertScheduler->updateFocus(avsCommon::avs::FocusState::BACKGROUND);
|
|
|
|
AlertScheduler::AlertsContextInfo resultContextInfo = m_alertScheduler->getContextInfo();
|
|
|
|
const unsigned int expectedRemainingScheduledAlerts = 2;
|
|
const unsigned int expectedRemainingActiveAlerts = 1;
|
|
|
|
/// Check that 2 alerts were scheduled, one of which is active.
|
|
ASSERT_EQ(resultContextInfo.scheduledAlerts.size(), expectedRemainingScheduledAlerts);
|
|
ASSERT_EQ(resultContextInfo.activeAlerts.size(), expectedRemainingActiveAlerts);
|
|
}
|
|
|
|
/**
|
|
* Test local stop on AlertScheduler
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onLocalStop) {
|
|
std::shared_ptr<TestAlert> alert = doSimpleTestSetup(true);
|
|
|
|
m_alertScheduler->onLocalStop();
|
|
|
|
ASSERT_EQ(alert->getState(), Alert::State::STOPPING);
|
|
ASSERT_EQ(alert->getStopReason(), Alert::StopReason::LOCAL_STOP);
|
|
}
|
|
|
|
/**
|
|
* Test if AlertScheduler clears data
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_clearData) {
|
|
std::shared_ptr<TestAlert> alert = doSimpleTestSetup(true);
|
|
EXPECT_CALL(*(m_alertStorage.get()), clearDatabase()).Times(1);
|
|
|
|
m_alertScheduler->clearData();
|
|
|
|
ASSERT_EQ(alert->getState(), Alert::State::STOPPING);
|
|
ASSERT_EQ(alert->getStopReason(), Alert::StopReason::SHUTDOWN);
|
|
}
|
|
|
|
/**
|
|
* Test if AlertScheduler clears data
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_clearDataLogout) {
|
|
std::shared_ptr<TestAlert> alert = doSimpleTestSetup(true);
|
|
EXPECT_CALL(*(m_alertStorage.get()), clearDatabase()).Times(1);
|
|
|
|
m_alertScheduler->clearData(Alert::StopReason::LOG_OUT);
|
|
|
|
ASSERT_EQ(alert->getState(), Alert::State::STOPPING);
|
|
ASSERT_EQ(alert->getStopReason(), Alert::StopReason::LOG_OUT);
|
|
}
|
|
|
|
/**
|
|
* Test if AlertScheduler shuts down appropriately
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_shutdown) {
|
|
doSimpleTestSetup(true);
|
|
|
|
m_alertScheduler->shutdown();
|
|
|
|
const unsigned int expectedRemainingAlerts = 0;
|
|
/// check if all scheduled alerts are cleared out
|
|
ASSERT_EQ(m_alertScheduler->getContextInfo().scheduledAlerts.size(), expectedRemainingAlerts);
|
|
}
|
|
|
|
/**
|
|
* Test Alert state change to Active on an inactive alert
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onAlertStateChangeStartedInactiveAlert) {
|
|
const std::string testReason = "stateStarted";
|
|
auto testState = AlertScheduler::State::STARTED;
|
|
|
|
doSimpleTestSetup(false, true);
|
|
|
|
/// check that we ignore inactive alerts
|
|
EXPECT_CALL(*(m_alertStorage.get()), modify(testing::_)).Times(0);
|
|
m_alertScheduler->onAlertStateChange(ALERT1_TOKEN, ALERT_TYPE, testState, testReason);
|
|
}
|
|
|
|
/**
|
|
* Test Alert state change to Active on an active alert
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onAlertStateChangeStartedActiveAlert) {
|
|
const std::string testReason = "stateStarted";
|
|
auto testState = AlertScheduler::State::STARTED;
|
|
|
|
doSimpleTestSetup(true, true);
|
|
|
|
/// active alerts should be handled
|
|
EXPECT_CALL(*(m_alertStorage.get()), modify(testing::_)).Times(1);
|
|
m_alertScheduler->onAlertStateChange(ALERT1_TOKEN, ALERT_TYPE, testState, testReason);
|
|
ASSERT_TRUE(m_testAlertObserver->waitFor(testState));
|
|
}
|
|
|
|
/**
|
|
* Test Alert state change to Stopped
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onAlertStateChangeStopped) {
|
|
const std::string testReason = "stateStopped";
|
|
auto testState = AlertScheduler::State::STOPPED;
|
|
|
|
doSimpleTestSetup(true, true);
|
|
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(1);
|
|
m_alertScheduler->onAlertStateChange(ALERT1_TOKEN, ALERT_TYPE, testState, testReason);
|
|
ASSERT_TRUE(m_testAlertObserver->waitFor(testState));
|
|
}
|
|
|
|
/**
|
|
* Test Alert state change to Completed
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onAlertStateChangeCompleted) {
|
|
const std::string testReason = "stateCompleted";
|
|
auto testState = AlertScheduler::State::COMPLETED;
|
|
|
|
doSimpleTestSetup(true, true);
|
|
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(1);
|
|
m_alertScheduler->onAlertStateChange(ALERT1_TOKEN, ALERT_TYPE, testState, testReason);
|
|
ASSERT_TRUE(m_testAlertObserver->waitFor(testState));
|
|
}
|
|
|
|
/**
|
|
* Test Alert state change to Snoozed
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onAlertStateChangeSnoozed) {
|
|
const std::string testReason = "stateSnoozed";
|
|
auto testState = AlertScheduler::State::SNOOZED;
|
|
|
|
doSimpleTestSetup(true, true);
|
|
|
|
EXPECT_CALL(*(m_alertStorage.get()), modify(testing::_)).Times(1);
|
|
m_alertScheduler->onAlertStateChange(ALERT1_TOKEN, ALERT_TYPE, testState, testReason);
|
|
ASSERT_TRUE(m_testAlertObserver->waitFor(testState));
|
|
}
|
|
|
|
/**
|
|
* Test Alert state change to Error on an active alert
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onAlertStateChangeErrorActiveAlert) {
|
|
const std::string testReason = "stateError";
|
|
auto testState = AlertScheduler::State::ERROR;
|
|
|
|
doSimpleTestSetup(true, true);
|
|
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(1);
|
|
m_alertScheduler->onAlertStateChange(ALERT1_TOKEN, ALERT_TYPE, testState, testReason);
|
|
ASSERT_TRUE(m_testAlertObserver->waitFor(testState));
|
|
}
|
|
|
|
/**
|
|
* Test Alert state change to Error on an inactive alert
|
|
*/
|
|
TEST_F(AlertSchedulerTest, test_onAlertStateChangeErrorInactiveAlert) {
|
|
const std::string testReason = "stateError";
|
|
auto testState = AlertScheduler::State::ERROR;
|
|
|
|
doSimpleTestSetup(false, true);
|
|
|
|
EXPECT_CALL(*(m_alertStorage.get()), erase(testing::_)).Times(1);
|
|
m_alertScheduler->onAlertStateChange(ALERT1_TOKEN, ALERT_TYPE, testState, testReason);
|
|
ASSERT_TRUE(m_testAlertObserver->waitFor(testState));
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace acsdkAlerts
|
|
} // namespace alexaClientSDK
|