UvosSmartHomeInterface/tests/unit/actors/test_actor.cpp

#include <QtTest/QtTest>
#include "actors/actor.h"
#include "actors/timeractor.h"
#include "actors/sensoractor.h"

class TestActor : public QObject
{
    Q_OBJECT

private slots:
    void initTestCase()
    {
        // Setup for all tests
    }

    void testActorCreation()
    {
        Actor actor;
        
        // Actor should be active by default
        QVERIFY(actor.isActive());
        
        // Actor should not be exhausted by default
        QVERIFY(!actor.isExausted());
    }

    void testActorActivation()
    {
        Actor actor;
        
        // Test makeActive/makeInactive
        actor.makeActive();
        QVERIFY(actor.isActive());
        
        actor.makeInactive();
        QVERIFY(!actor.isActive());
    }

    void testActorSetActive()
    {
        Actor actor;
        
        // Test setActive
        actor.setActive(1);
        QVERIFY(actor.isActive());
        
        actor.setActive(0);
        QVERIFY(!actor.isActive());
    }

    void testActorTriggerValue()
    {
        Actor actor;
        
        // Default trigger value should be 0
        QVERIFY(actor.getTriggerValue() == 0);
        
        // Set trigger value
        actor.setTriggerValue(1);
        QVERIFY(actor.getTriggerValue() == 1);
        
        actor.setTriggerValue(255);
        QVERIFY(actor.getTriggerValue() == 255);
    }

    void testActorActionName()
    {
        Actor actor;
        
        // Default trigger value is 0, so action name should be "off"
        QVERIFY(actor.actionName() == "off");
        
        // Set trigger value to 1
        actor.setTriggerValue(1);
        QVERIFY(actor.actionName() == "on");
        
        // Set trigger value to something else
        actor.setTriggerValue(5);
        QVERIFY(actor.actionName() == "value to 5");
    }

    void testActorJsonSerialization()
    {
        Actor actor;
        actor.setTriggerValue(1);
        actor.makeInactive();
        
        QJsonObject json;
        actor.store(json);
        
        // Verify JSON contents
        QVERIFY(json.contains("Active"));
        QVERIFY(json.contains("Exausted"));
        QVERIFY(json.contains("TriggerValue"));
        
        QVERIFY(json["Active"].toBool() == false);
        QVERIFY(json["Exausted"].toBool() == false);
        QVERIFY(json["TriggerValue"].toInt() == 1);
    }

    void testActorJsonDeserialization()
    {
        QJsonObject json;
        json["Active"] = false;
        json["Exausted"] = true;
        json["TriggerValue"] = 5;
        
        Actor actor;
        actor.load(json);
        
        QVERIFY(actor.isActive() == false);
        QVERIFY(actor.isExausted() == true);
        QVERIFY(actor.getTriggerValue() == 5);
    }

    void testActorCreateActor()
    {
        // Test creating different actor types
        std::shared_ptr<Actor> alarmActor = Actor::createActor("Alarm");
        QVERIFY(alarmActor != nullptr);
        
        std::shared_ptr<Actor> sensorActor = Actor::createActor("Sensor");
        QVERIFY(sensorActor != nullptr);
        
        std::shared_ptr<Actor> timerActor = Actor::createActor("Timer");
        QVERIFY(timerActor != nullptr);
        
        std::shared_ptr<Actor> regulatorActor = Actor::createActor("Regulator");
        QVERIFY(regulatorActor != nullptr);
        
        std::shared_ptr<Actor> polynomalActor = Actor::createActor("Polynomal");
        QVERIFY(polynomalActor != nullptr);
        
        std::shared_ptr<Actor> factorActor = Actor::createActor("MultiFactor");
        QVERIFY(factorActor != nullptr);
        
        std::shared_ptr<Actor> genericActor = Actor::createActor("Actor");
        QVERIFY(genericActor != nullptr);
        
        // Test unknown type returns nullptr
        std::shared_ptr<Actor> unknownActor = Actor::createActor("UnknownType");
        QVERIFY(unknownActor == nullptr);
    }

    void testActorLoadActor()
    {
        QJsonObject json;
        json["Type"] = "Timer";
        json["Active"] = true;
        json["Exausted"] = false;
        json["TriggerValue"] = 1;
        json["Timeout"] = 5000;
        
        std::shared_ptr<Actor> actor = Actor::loadActor(json);
        QVERIFY(actor != nullptr);
        
        // Verify the actor was loaded with correct values
        QVERIFY(actor->isActive());
        QVERIFY(!actor->isExausted());
        QVERIFY(actor->getTriggerValue() == 1);
    }

    void testTimerActorCreation()
    {
        TimerActor actor(60);
        
        // Default timeout should be 60 seconds
        QVERIFY(actor.getTimeout() == 60);
    }

    void testTimerActorSetTimeout()
    {
        TimerActor actor(60);
        
        actor.setTimeout(120);
        QVERIFY(actor.getTimeout() == 120);
        
        actor.setTimeout(5);
        QVERIFY(actor.getTimeout() == 5);
    }

    void testTimerActorJsonSerialization()
    {
        TimerActor actor(120);
        
        QJsonObject json;
        actor.store(json);
        
        // Verify JSON contents
        QVERIFY(json.contains("Type"));
        QVERIFY(json.contains("Timeout"));
        
        QVERIFY(json["Type"].toString() == "Timer");
        QVERIFY(json["Timeout"].toInt() == 120000); // Converted to milliseconds
    }

    void testTimerActorJsonDeserialization()
    {
        QJsonObject json;
        json["Type"] = "Timer";
        json["Timeout"] = 30000; // 30 seconds in milliseconds
        json["Active"] = true;
        json["Exausted"] = false;
        json["TriggerValue"] = 1;
        
        TimerActor actor;
        actor.load(json, false);
        
        // Timeout should be 30 seconds
        QVERIFY(actor.getTimeout() == 30);
    }

    void testTimerActorGetName()
    {
        TimerActor actor(60);
        
        QString name = actor.getName();
        QVERIFY(name.contains("60"));
    }

    void testSensorActorCreation()
    {
        Sensor sensor(Sensor::TYPE_TEMPERATURE, 1, 25.0, "temp_sensor");
        SensorActor actor(sensor);
        
        // Verify sensor was set correctly
        QVERIFY(actor.getSensor().type == Sensor::TYPE_TEMPERATURE);
        QVERIFY(actor.getSensor().id == 1);
    }

    void testSensorActorDefaultCreation()
    {
        SensorActor actor;
        
        // Default sensor should be dummy
        QVERIFY(actor.getSensor().type == Sensor::TYPE_DUMMY);
    }

    void testSensorActorSetSensor()
    {
        SensorActor actor;
        
        Sensor newSensor(Sensor::TYPE_HUMIDITY, 2, 60.0, "humidity_sensor");
        actor.setSensor(newSensor);
        
        QVERIFY(actor.getSensor().type == Sensor::TYPE_HUMIDITY);
        QVERIFY(actor.getSensor().id == 2);
    }

    void testSensorActorSetThreshold()
    {
        SensorActor actor;
        
        actor.setThreshold(25.0);
        QVERIFY(actor.getThreshold() == 25.0);
    }

    void testSensorActorSetSlope()
    {
        SensorActor actor;
        
        actor.setSloap(SensorActor::SLOPE_UP);
        QVERIFY(actor.getSloap() == SensorActor::SLOPE_UP);
        
        actor.setSloap(SensorActor::SLOPE_DOWN);
        QVERIFY(actor.getSloap() == SensorActor::SLOPE_DOWN);
        
        actor.setSloap(SensorActor::SLOPE_BOTH);
        QVERIFY(actor.getSloap() == SensorActor::SLOPE_BOTH);
    }

    void testSensorActorJsonSerialization()
    {
        Sensor sensor(Sensor::TYPE_TEMPERATURE, 1, 25.0, "temp_sensor");
        SensorActor actor(sensor);
        actor.setThreshold(30.0);
        actor.setSloap(SensorActor::SLOPE_UP);
        
        QJsonObject json;
        actor.store(json);
        
        // Verify JSON contents
        QVERIFY(json.contains("Type"));
        QVERIFY(json.contains("Threshold"));
        QVERIFY(json.contains("Sloap"));
        QVERIFY(json.contains("SensorType"));
        
        QVERIFY(json["Type"].toString() == "Sensor");
        QVERIFY(json["Threshold"].toDouble() == 30.0);
        QVERIFY(json["Sloap"].toInt() == SensorActor::SLOPE_UP);
    }

    void testSensorActorJsonDeserialization()
    {
        QJsonObject json;
        json["Type"] = "Sensor";
        json["Threshold"] = 25.5;
        json["Sloap"] = SensorActor::SLOPE_DOWN;
        json["SensorType"] = Sensor::TYPE_HUMIDITY;
        json["SensorId"] = 3;
        json["SensorField"] = 65.0;
        json["SensorName"] = "humidity";
        json["Active"] = true;
        json["Exausted"] = false;
        json["TriggerValue"] = 1;
        
        SensorActor actor;
        actor.load(json, false);
        
        QVERIFY(actor.getThreshold() == 25.5);
        QVERIFY(actor.getSloap() == SensorActor::SLOPE_DOWN);
    }

    void testSensorActorGetName()
    {
        Sensor sensor(Sensor::TYPE_TEMPERATURE, 1, 25.0, "temp_sensor");
        SensorActor actor(sensor);
        actor.setThreshold(30.0);
        
        QString name = actor.getName();
        QVERIFY(name.contains("temp_sensor"));
        QVERIFY(name.contains("30"));
    }

    void cleanupTestCase()
    {
        // Cleanup after all tests
    }
};

QTEST_APPLESS_MAIN(TestActor)

#include "test_actor.moc"