Skip to content
GitLab

Scenario states

Merged Christian Hitz requested to merge chhitz/dss-mainline:DSD-2126-scenario-states into master
All threads resolved!
Compare
and
27 files
+ 855
− 352
src/cache/cache-db-test.cpp
+ 5
− 3
@@ -53,7 +53,8 @@ DS_REFLECT_ANONYMOUS_STRUCT(TestEntry2, (a));
namespace {
SCENARIO("Normal operation", TAGS) {
CacheDb<TestEntry> db("cache.db", ds::sqlite3::Database::Mode::ReadWrite);
ds::sqlite3::Database d("cache.db");
CacheDb<TestEntry> db(&d);
TestEntry X{42, std::string("device-caching ?/)")};
TestEntry Empty{};
GIVEN("an empty cache") {
@@ -125,10 +126,11 @@ SCENARIO("Normal operation", TAGS) {
}
SCENARIO("Multiple cache instances", TAGS) {
ds::sqlite3::Database d("cache.db");
GIVEN("There are 2 cache instances for different types") {
CacheDb<TestEntry> db1("cache.db", ds::sqlite3::Database::Mode::ReadWrite);
CacheDb<TestEntry> db1(&d);
db1.empty();
CacheDb<TestEntry2> db2("cache.db", ds::sqlite3::Database::Mode::ReadWrite);
CacheDb<TestEntry2> db2(&d);
db2.empty();
TestEntry X1{42, std::string("device-caching ?/)")};
TestEntry2 X2{99};
src/cache/cache-db.h
+ 9
− 10
@@ -39,17 +39,17 @@ public:
void remove(const Dsuid& dsuid) {
std::lock_guard<std::mutex> lock(m_mutex);
DS_CONTEXT(m_tableName, dsuid);
m_db.exec("DELETE FROM " + m_tableName + " WHERE dsuid = ?;", dsuid2str(dsuid));
m_db->exec("DELETE FROM " + m_tableName + " WHERE dsuid = ?;", dsuid2str(dsuid));
}
void empty() {
std::lock_guard<std::mutex> lock(m_mutex);
DS_CONTEXT(m_tableName);
m_db.exec("DELETE FROM " + m_tableName + ";");
m_db->exec("DELETE FROM " + m_tableName + ";");
}
protected:
CacheDbBase(const std::string& path, ds::sqlite3::Database::Mode mode) : m_db(path.c_str(), mode) {}
CacheDbBase(ds::sqlite3::Database* db) : m_db(db) {}
void setTableName(const std::string& name) {
m_tableName = name;
@@ -59,11 +59,11 @@ protected:
private:
void initializeDbTable() {
std::lock_guard<std::mutex> lock(m_mutex);
m_db.exec("CREATE TABLE IF NOT EXISTS " + m_tableName + " (dsuid TEXT(40) UNIQUE, data);");
m_db->exec("CREATE TABLE IF NOT EXISTS " + m_tableName + " (dsuid TEXT(40) UNIQUE, data);");
}
protected:
ds::sqlite3::Database m_db;
ds::sqlite3::Database* m_db;
std::string m_tableName;
inline static std::mutex m_mutex;
};
@@ -71,8 +71,7 @@ protected:
template <typename T>
class CacheDb : public CacheDbBase {
public:
CacheDb(const std::string& path, ds::sqlite3::Database::Mode mode = ds::sqlite3::Database::Mode::ReadWrite)
: CacheDbBase(path, mode) {
CacheDb(ds::sqlite3::Database* db) : CacheDbBase(db) {
char* name = abi::__cxa_demangle(typeid(T).name(), 0, 0, NULL);
std::string typeName(name);
setTableName(typeName.substr(typeName.find_last_of(":") + 1) + "_table");
@@ -84,7 +83,7 @@ public:
DS_CONTEXT(m_tableName, dsuid);
try {
std::string entryStr;
std::tie(entryStr) = m_db.exec("SELECT data FROM " + m_tableName + " WHERE dsuid = ?;", dsuid2str(dsuid))
std::tie(entryStr) = m_db->exec("SELECT data FROM " + m_tableName + " WHERE dsuid = ?;", dsuid2str(dsuid))
.template row<std::string>();
DS_CHANNEL_DEBUG(dbLogChannel, entryStr);
auto entry = ds::fromJson<T>(entryStr);
@@ -99,8 +98,8 @@ public:
std::lock_guard<std::mutex> lock(m_mutex);
DS_CONTEXT(m_tableName, dsuid);
DS_CHANNEL_DEBUG(dbLogChannel, ds::toJson(entry));
m_db.exec("INSERT OR REPLACE INTO " + m_tableName + " (dsuid, data) VALUES(?, ?);", dsuid2str(dsuid),
ds::toJson(entry));
m_db->exec("INSERT OR REPLACE INTO " + m_tableName + " (dsuid, data) VALUES(?, ?);", dsuid2str(dsuid),
ds::toJson(entry));
}
};
src/cache/cache-test.cpp
+ 299
− 21
@@ -28,6 +28,7 @@
#include "ds/log.h"
#include "ds485/dsactionrequest.h"
#include "dsm-api-mock.h"
#include "hal/hardware-abstraction-mock.h"
#include "model/apartment.h"
#include "model/group.h"
#include "model/set.h"
@@ -45,12 +46,16 @@ namespace {
static const Dsuid dsuid1{"0000000000000000000000000000000001"};
static const Dsuid dsuid2{"0000000000000000000000000000000002"};
static const Dsuid dsuid3{"0000000000000000000000000000000003"};
static const Dsuid dsuid4{"0000000000000000000000000000000004"};
static const Dsuid dsuid5{"0000000000000000000000000000000005"};
SCENARIO("SaveScene invocation", TAGS) {
GIVEN("The cache contains 3 devices") {
CacheDb<DeviceCache> cacheDb("cache.db");
ds::sqlite3::Database d(":memory:");
CacheDb<DeviceCache> cacheDb(&d);
Apartment apt(DS_NULLPTR);
Cache cache(apt, "cache.db");
HardwareAbstraction hal{&apt, &d};
Cache cache(&apt, &hal, &d);
DeviceCache A;
A.scene.sceneTable[1].channels[ChannelType::brightness].value = 11;
A.scene.sceneTable[2].channels[ChannelType::brightness].value = 21;
@@ -76,18 +81,14 @@ SCENARIO("SaveScene invocation", TAGS) {
REQUIRE(*cacheDb.tryLookup(dsuid1).scene.sceneTable[2].channels[ChannelType::brightness].value == 21);
}
AND_THEN("values for the other devices are still intact") {
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[1].channels[ChannelType::shadePositionOutside].value ==
12);
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[2].channels[ChannelType::shadePositionOutside].value ==
22);
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[1].channels[ChannelType::shadePositionOutside].value == 12);
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[2].channels[ChannelType::shadePositionOutside].value == 22);
REQUIRE(*cacheDb.tryLookup(dsuid3).scene.sceneTable[1].channels[ChannelType::brightness].value == 13);
REQUIRE(
*cacheDb.tryLookup(dsuid3).scene.sceneTable[1].channels[ChannelType::shadeOpeningAngleOutside].value ==
14);
REQUIRE(*cacheDb.tryLookup(dsuid3).scene.sceneTable[1].channels[ChannelType::shadeOpeningAngleOutside].value ==
14);
REQUIRE(*cacheDb.tryLookup(dsuid3).scene.sceneTable[2].channels[ChannelType::brightness].value == 23);
REQUIRE(
*cacheDb.tryLookup(dsuid3).scene.sceneTable[2].channels[ChannelType::shadeOpeningAngleOutside].value ==
24);
REQUIRE(*cacheDb.tryLookup(dsuid3).scene.sceneTable[2].channels[ChannelType::shadeOpeningAngleOutside].value ==
24);
}
}
@@ -96,22 +97,18 @@ SCENARIO("SaveScene invocation", TAGS) {
THEN("values for scene 1 are deleted") {
REQUIRE(!cacheDb.tryLookup(dsuid3).scene.sceneTable[1].channels[ChannelType::brightness].value);
REQUIRE(
!cacheDb.tryLookup(dsuid3).scene.sceneTable[1].channels[ChannelType::shadeOpeningAngleOutside].value);
REQUIRE(!cacheDb.tryLookup(dsuid3).scene.sceneTable[1].channels[ChannelType::shadeOpeningAngleOutside].value);
}
AND_THEN("values for the other scenes are still intact") {
REQUIRE(*cacheDb.tryLookup(dsuid3).scene.sceneTable[2].channels[ChannelType::brightness].value == 23);
REQUIRE(
*cacheDb.tryLookup(dsuid3).scene.sceneTable[2].channels[ChannelType::shadeOpeningAngleOutside].value ==
24);
REQUIRE(*cacheDb.tryLookup(dsuid3).scene.sceneTable[2].channels[ChannelType::shadeOpeningAngleOutside].value ==
24);
}
AND_THEN("values for the other device are still intact") {
REQUIRE(*cacheDb.tryLookup(dsuid1).scene.sceneTable[1].channels[ChannelType::brightness].value == 11);
REQUIRE(*cacheDb.tryLookup(dsuid1).scene.sceneTable[2].channels[ChannelType::brightness].value == 21);
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[1].channels[ChannelType::shadePositionOutside].value ==
12);
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[2].channels[ChannelType::shadePositionOutside].value ==
22);
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[1].channels[ChannelType::shadePositionOutside].value == 12);
REQUIRE(*cacheDb.tryLookup(dsuid2).scene.sceneTable[2].channels[ChannelType::shadePositionOutside].value == 22);
}
}
@@ -125,4 +122,285 @@ SCENARIO("SaveScene invocation", TAGS) {
}
}
SCENARIO("Scenario state", TAGS) {
ds::sqlite3::Database db(":memory:");
Apartment apt(DS_NULLPTR);
MockHal hal(&apt, &db);
auto zone1 = apt.allocateZone(1);
auto zone2 = apt.allocateZone(2);
auto dev1 = apt.allocateDevice(dsuid1);
dev1->addToGroup(1);
dev1->setIsPresent(true);
dev1->setIsConnected(true);
auto dev2 = apt.allocateDevice(dsuid2);
dev2->addToGroup(1);
dev2->setIsPresent(true);
dev2->setIsConnected(true);
auto dev3 = apt.allocateDevice(dsuid3);
dev3->addToGroup(1);
dev3->setIsPresent(true);
dev3->setIsConnected(true);
auto dev4 = apt.allocateDevice(dsuid4);
dev4->addToGroup(2);
dev4->setIsPresent(true);
dev4->setIsConnected(true);
auto dev5 = apt.allocateDevice(dsuid5);
dev5->addToGroup(2);
dev5->setIsPresent(false);
dev5->setIsConnected(false);
DeviceReference d1(dev1, &apt);
DeviceReference d2(dev2, &apt);
DeviceReference d3(dev3, &apt);
DeviceReference d4(dev4, &apt);
DeviceReference d5(dev5, &apt);
zone1->addDevice(d1);
zone1->addDevice(d2);
zone2->addDevice(d3);
zone2->addDevice(d4);
zone2->addDevice(d5);
Cache cache{&apt, &hal, &db};
CacheDb<ScenarioCache> sc{&db};
CacheDb<DeviceCache> dc{&db};
{
auto cache = dc.tryLookup(dsuid1);
cache.scene.sceneTable[0].flags.dontCare = false;
cache.scene.sceneTable[5].flags.dontCare = false;
cache.scene.sceneTable[17].flags.dontCare = true;
cache.scene.sceneTable[18].flags.dontCare = false;
dc.update(dsuid1, cache);
}
{
auto cache = dc.tryLookup(dsuid2);
cache.scene.sceneTable[0].flags.dontCare = false;
cache.scene.sceneTable[5].flags.dontCare = true;
cache.scene.sceneTable[17].flags.dontCare = false;
cache.scene.sceneTable[18].flags.dontCare = false;
dc.update(dsuid2, cache);
}
{
auto cache = dc.tryLookup(dsuid3);
cache.scene.sceneTable[0].flags.dontCare = false;
dc.update(dsuid3, cache);
}
{
auto cache = dc.tryLookup(dsuid4);
cache.scene.sceneTable[0].flags.dontCare = false;
cache.scene.sceneTable[5].flags.dontCare = false;
dc.update(dsuid4, cache);
}
GIVEN("A scene is called in a zone/group") {
REQUIRE_CALL(hal, callScene(dsuid1, 5, false, _)).RETURN(true);
REQUIRE_CALL(hal, callScene(dsuid2, 5, false, _)).RETURN(false);
REQUIRE_NOTHROW(cache.callScene(1, 1, 5, false));
{
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::active);
}
WHEN("A device changes disjunct state") {
REQUIRE_CALL(hal, callScene(dsuid1, 17, false, _)).RETURN(false);
REQUIRE_CALL(hal, callScene(dsuid2, 17, false, _)).RETURN(true);
REQUIRE_NOTHROW(cache.callScene(1, 1, 17, false));
THEN("the scenario stays active") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::active);
REQUIRE(scenario.scenarios["z1-g1-s17"].status == dsModel::ScenarioStatusStatus::active);
}
}
WHEN("A device changes shared state") {
REQUIRE_CALL(hal, callScene(dsuid1, 18, false, _)).RETURN(true);
REQUIRE_CALL(hal, callScene(dsuid2, 18, false, _)).RETURN(true);
REQUIRE_NOTHROW(cache.callScene(1, 1, 18, false));
THEN("the scenario stays active") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
REQUIRE(scenario.scenarios["z1-g1-s18"].status == dsModel::ScenarioStatusStatus::active);
}
}
WHEN("callSceneMin is called") {
REQUIRE_CALL(hal, callSceneMin(dsuid1, 5, _)).RETURN(true);
REQUIRE_CALL(hal, callSceneMin(dsuid2, 5, _)).RETURN(false);
REQUIRE_NOTHROW(cache.callSceneMin(1, 1, 5));
THEN("the scenario becomes inactive") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("undoScene is called") {
REQUIRE_CALL(hal, undoScene(dsuid1, 5, _)).RETURN(true);
REQUIRE_CALL(hal, undoScene(dsuid2, 5, _)).RETURN(false);
REQUIRE_NOTHROW(cache.undoScene(1, 1, 5));
THEN("the scenario becomes inactive ") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("setOutputValue is called") {
REQUIRE_CALL(hal, setOutputValue(dsuid1, _, _)).RETURN(true);
REQUIRE_CALL(hal, setOutputValue(dsuid2, _, _)).RETURN(false);
REQUIRE_NOTHROW(cache.setOutputValue(1, 1, 58));
THEN("the scenario becomes inactive ") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("A device callScene is called") {
REQUIRE_CALL(hal, callScene(dsuid1, 17, false, _)).RETURN(true);
REQUIRE_NOTHROW(cache.callScene(dsuid1, 17, false));
THEN("the scenario becomes active") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
REQUIRE(scenario.scenarios["z1-g1-s17"].status == dsModel::ScenarioStatusStatus::none);
}
}
WHEN("callSceneMin is called on device") {
REQUIRE_CALL(hal, callSceneMin(dsuid1, 5, _)).RETURN(true);
REQUIRE_NOTHROW(cache.callSceneMin(dsuid1, 5));
THEN("the scenario becomes inactive") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("undoScene is called on device") {
REQUIRE_CALL(hal, undoScene(dsuid1, 5, _)).RETURN(true);
REQUIRE_NOTHROW(cache.undoScene(dsuid1, 5));
THEN("the scenario becomes inactive ") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("setOutputValue is called on device") {
REQUIRE_CALL(hal, setOutputValue(dsuid1, 58, _)).RETURN(true);
REQUIRE_NOTHROW(cache.setOutputValue(dsuid1, 58));
THEN("the scenario becomes inactive ") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("setOutputValue is called on device") {
REQUIRE_CALL(hal, setOutputValue(dsuid1, ChannelType::brightness, 58.25, _)).RETURN(true);
REQUIRE_NOTHROW(cache.setOutputValue(dsuid1, ChannelType::brightness, 58.25));
THEN("the scenario becomes inactive ") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("setSceneLocalPrio is called on device") {
REQUIRE_CALL(hal, setSceneLocalPrio(dsuid1, 5));
REQUIRE_NOTHROW(cache.setSceneLocalPrio(dsuid1, 5));
THEN("the scenario does not change") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::active);
}
}
WHEN("setOperationLock is called on device") {
REQUIRE_CALL(hal, setOperationLock(dsuid1, true));
REQUIRE_NOTHROW(cache.setOperationLock(dsuid1, 5));
THEN("the scenario does not change") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::active);
}
}
WHEN("Querying scenarios work") {
auto scenarioStatus = cache.zoneScenarioStatus(1);
REQUIRE(scenarioStatus[0].id == "z1-g1-s5");
REQUIRE(scenarioStatus[0].status == dsModel::ScenarioStatusStatus::active);
}
}
GIVEN("A scene is called in the whole apartment") {
REQUIRE_CALL(hal, callScene(dsuid1, 5, false, _)).RETURN(true);
REQUIRE_CALL(hal, callScene(dsuid2, 5, false, _)).RETURN(false);
REQUIRE_CALL(hal, callScene(dsuid3, 5, false, _)).RETURN(true);
REQUIRE_NOTHROW(cache.callScene(0, 1, 5, false));
{
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z0-g1-s5"].status == dsModel::ScenarioStatusStatus::active);
}
WHEN("A device changes in a zone state") {
REQUIRE_CALL(hal, callScene(dsuid1, 5, false, _)).RETURN(true);
REQUIRE_CALL(hal, callScene(dsuid2, 5, false, _)).RETURN(false);
REQUIRE_NOTHROW(cache.callScene(1, 1, 5, false));
THEN("the apartment scenario becomes inactive") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z1-g1-s5"].status == dsModel::ScenarioStatusStatus::active);
REQUIRE(scenario.scenarios["z0-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("A device changes in another group") {
REQUIRE_CALL(hal, callScene(dsuid4, 5, false, _)).RETURN(true);
REQUIRE_NOTHROW(cache.callScene(2, 2, 5, false));
THEN("the apartment scenario stays active") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z0-g1-s5"].status == dsModel::ScenarioStatusStatus::active);
REQUIRE(scenario.scenarios["z2-g2-s5"].status == dsModel::ScenarioStatusStatus::active);
}
}
WHEN("An broadcast scene is called") {
REQUIRE_CALL(hal, callScene(dsuid1, 0, false, _)).RETURN(true);
REQUIRE_CALL(hal, callScene(dsuid2, 0, false, _)).RETURN(true);
REQUIRE_CALL(hal, callScene(dsuid3, 0, false, _)).RETURN(true);
REQUIRE_CALL(hal, callScene(dsuid4, 0, false, _)).RETURN(true);
REQUIRE_NOTHROW(cache.callScene(0, 0, 0, false));
THEN("all scenarios are inactive") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z0-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
REQUIRE(scenario.scenarios["z0-g0-s0"].status == dsModel::ScenarioStatusStatus::active);
}
}
WHEN("callSceneMin is called") {
REQUIRE_CALL(hal, callSceneMin(dsuid1, 5, _)).RETURN(true);
REQUIRE_CALL(hal, callSceneMin(dsuid2, 5, _)).RETURN(false);
REQUIRE_NOTHROW(cache.callSceneMin(1, 1, 5));
THEN("the scenario becomes inactive") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z0-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("undoScene is called") {
REQUIRE_CALL(hal, undoScene(dsuid1, 5, _)).RETURN(true);
REQUIRE_CALL(hal, undoScene(dsuid2, 5, _)).RETURN(false);
REQUIRE_NOTHROW(cache.undoScene(1, 1, 5));
THEN("the scenario becomes inactive ") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z0-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
WHEN("setOutputValue is called") {
REQUIRE_CALL(hal, setOutputValue(dsuid1, _, _)).RETURN(true);
REQUIRE_CALL(hal, setOutputValue(dsuid2, _, _)).RETURN(false);
REQUIRE_NOTHROW(cache.setOutputValue(1, 1, 58));
THEN("the scenario becomes inactive ") {
auto scenario = sc.tryLookup(DSUID_NULL);
REQUIRE(scenario.scenarios["z0-g1-s5"].status == dsModel::ScenarioStatusStatus::inactive);
}
}
}
}
} // namespace
src/cache/cache-updater-test.cpp
+ 5
− 13
@@ -29,6 +29,7 @@
#include "ds/json.h"
#include "ds/log.h"
#include "event-mock.h"
#include "hal/hardware-abstraction-mock.h"
#include "hal/hardware-abstraction.h"
#include "model/apartment.h"
#include "model/modelmaintenance-mock.h"
@@ -41,14 +42,6 @@ using namespace dss;
using namespace trompeloeil;
using trompeloeil::_;
class MockHal : public HardwareAbstraction {
public:
explicit MockHal(const Apartment& apt, const std::string& dbPath) : HardwareAbstraction(apt, dbPath) {}
MAKE_CONST_MOCK2(readDouble, double(const Dsuid& dsuid, const std::string& parameter), override);
MAKE_CONST_MOCK2(readString, std::string(const Dsuid& dsuid, const std::string& parameter), override);
MAKE_CONST_MOCK2(readBool, bool(const Dsuid& dsuid, const std::string& parameter), override);
};
namespace {
static const Dsuid dsuid1{"0000000000000000000000000000000001"};
@@ -56,10 +49,9 @@ static const Dsuid dsuid2{"0000000000000000000000000000000002"};
static const Dsuid dsuid3{"0000000000000000000000000000000003"};
SCENARIO("A device gets added to cache", TAGS) {
remove("cache.db");
Apartment apt(DS_NULLPTR);
CacheDb<DeviceCache> db("cache.db");
ds::sqlite3::Database d(":memory:");
CacheDb<DeviceCache> db(&d);
BusInterfaceMock busInterface;
DeviceBusInterfaceMock deviceBusInterface;
EventSinkMock eventSink;
@@ -81,8 +73,8 @@ SCENARIO("A device gets added to cache", TAGS) {
apt.setEventSink(eventSink);
apt.setModelMaintenance(&modelMaintenance);
MockHal hal(apt, "cache.db");
CacheUpdatePlugin interface(apt, hal, interpreter, propSystem, queue, runner);
MockHal hal(&apt, &d);
CacheUpdatePlugin interface(&apt, &hal, interpreter, propSystem, queue, runner);
GIVEN("A new device with no scene cache") {
DeviceSpec spec;
src/cache/cache-updater.cpp
+ 13
− 13
@@ -42,7 +42,7 @@ class CacheMissException : public std::runtime_error {
using std::runtime_error::runtime_error;
};
CacheUpdatePlugin::CacheUpdatePlugin(const Apartment& apt, HardwareAbstraction& hal, EventInterpreter& interpreter,
CacheUpdatePlugin::CacheUpdatePlugin(const Apartment* apt, HardwareAbstraction* hal, EventInterpreter& interpreter,
boost::shared_ptr<PropertySystem> propSystem,
boost::shared_ptr<EventQueue> eventQueue,
boost::shared_ptr<EventRunner> eventRunner)
@@ -60,7 +60,7 @@ CacheUpdatePlugin::~CacheUpdatePlugin() {}
bool CacheUpdatePlugin::updateIfNotCached(const Dsuid& dsuid, SceneFlags& flags, std::string path) {
if (!flags.dontCare || !flags.ignoreLocalPrio || !flags.specialHandling || !flags.blink || !flags.ledConfig ||
!flags.dimTime) {
m_hal.readBool(dsuid, path + "/dontCare");
m_hal->readBool(dsuid, path + "/dontCare");
return false;
}
@@ -77,10 +77,10 @@ bool CacheUpdatePlugin::updateIfNotCached(const Dsuid& dsuid, SceneEntry& entry,
// Figure out if this scene pertains to device
for (auto& channelPair : entry.channels) {
if (!channelPair.second.value) {
m_hal.readDouble(dsuid, path + "/" + ds::fromEnum<std::string>(channelPair.first));
m_hal->readDouble(dsuid, path + "/" + ds::fromEnum<std::string>(channelPair.first));
return false;
} else if (!channelPair.second.dontCare.is_initialized()) {
m_hal.readBool(dsuid, path + "/" + ds::fromEnum<std::string>(channelPair.first) + "/dontCare");
m_hal->readBool(dsuid, path + "/" + ds::fromEnum<std::string>(channelPair.first) + "/dontCare");
return false;
}
}
@@ -114,9 +114,9 @@ bool CacheUpdatePlugin::updateIfNotCached(const Dsuid& dsuid, DeviceCache& cache
std::stringstream propertyStr;
propertyStr << property.first;
if (property.first == DeviceProperty::outputMode) {
m_hal.readString(dsuid, path + "/property/" + propertyStr.str());
m_hal->readString(dsuid, path + "/property/" + propertyStr.str());
} else {
m_hal.readDouble(dsuid, path + "/property/" + propertyStr.str());
m_hal->readDouble(dsuid, path + "/property/" + propertyStr.str());
}
return false;
}
@@ -133,7 +133,7 @@ void CacheUpdatePlugin::reschedule() {
}
void CacheUpdatePlugin::addMissingScenes(const Dsuid& dsuid, DeviceCache& cacheEntry) {
const std::vector<int>& deviceScenes = m_hal.getApplicableScenes(dsuid);
const std::vector<int>& deviceScenes = m_hal->getApplicableScenes(dsuid);
std::vector<int> cacheScenes;
cacheScenes.reserve(cacheEntry.scene.sceneTable.size());
for (auto keyValPair : cacheEntry.scene.sceneTable) {
@@ -146,7 +146,7 @@ void CacheUpdatePlugin::addMissingScenes(const Dsuid& dsuid, DeviceCache& cacheE
std::inserter(diff, diff.begin()));
SceneEntry sceneEntry;
const std::vector<std::string>& deviceSceneChannels = m_hal.getSceneChannels(dsuid);
const std::vector<std::string>& deviceSceneChannels = m_hal->getSceneChannels(dsuid);
for (auto channel : deviceSceneChannels) {
sceneEntry.channels[ds::fromJson<ChannelType>(channel)] = {};
}
@@ -157,11 +157,11 @@ void CacheUpdatePlugin::addMissingScenes(const Dsuid& dsuid, DeviceCache& cacheE
cacheEntry.scene.sceneTable[missingKey] = sceneEntry;
}
m_hal.getCache().update(dsuid, cacheEntry);
m_hal->getCache().update(dsuid, cacheEntry);
}
void CacheUpdatePlugin::addMissingProperties(const Dsuid& dsuid, DeviceCache& cacheEntry) {
const std::vector<std::string>& deviceProperties = m_hal.getDeviceProperties(dsuid);
const std::vector<std::string>& deviceProperties = m_hal->getDeviceProperties(dsuid);
DS_DEBUG("properties before", cacheEntry.property);
for (auto& property : deviceProperties) {
@@ -173,12 +173,12 @@ void CacheUpdatePlugin::addMissingProperties(const Dsuid& dsuid, DeviceCache& ca
}
DS_DEBUG("properties after", cacheEntry.property);
m_hal.getCache().update(dsuid, cacheEntry);
m_hal->getCache().update(dsuid, cacheEntry);
}
void CacheUpdatePlugin::scanCache() {
DS_DEBUG("Scanning Device Scene Cache");
Set devices = m_apartment.getDevices().getByPresence(true);
Set devices = m_apartment->getDevices().getByPresence(true);
DS_DEBUG("Set size", devices.length());
@@ -194,7 +194,7 @@ void CacheUpdatePlugin::scanCache() {
for (int d = continueIndex; d < devices.length(); d++) {
boost::shared_ptr<Device> device = devices[d].getDevice();
DeviceCache cacheEntry = m_hal.getCache().tryLookup(device->getDSID());
DeviceCache cacheEntry = m_hal->getCache().tryLookup(device->getDSID());
DS_INFO("Device to scan ", dsuid2str(device->getDSID()), ds::toJson(cacheEntry));