testStatus.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq_test
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Test daq::Status and daq::ObservableStatus
 */
#include <daq/status.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include "statusObserver.hpp"
 
using namespace ::testing;
using namespace daq;
 
/**
 * ObservableStatus test fixture.
 *
 * @ingroup daq_ocm_libdaq_test
 */
class TestObservableStatus : public ::testing::Test {
public:
};
 
TEST_F(TestObservableStatus, Construct) {
    ObservableStatus s("id", "fileid");
}
 
TEST_F(TestObservableStatus, Comparison) {
    ObservableStatus s1("id", "fileid");
    ObservableStatus s2("id", "fileid");
    ObservableStatus s3("id", "fileid");
    s3.SetAlert(MakeAlert("cat", "key", "description"));
    EXPECT_EQ(s1, s2);
    EXPECT_NE(s1, s3);
}
 
TEST_F(TestObservableStatus, State) {
    ObservableStatus s("id", "fileid");
 
    EXPECT_EQ(State::NotStarted, s.GetState()) << "Default state should be State::NotStarted";
    EXPECT_FALSE(HasError(s)) << "By default error flag should be false";
 
    s.SetState(State::Starting);
    EXPECT_EQ(State::Starting, s.GetState());
}
 
TEST_F(TestObservableStatus, OstreamOperator) {
    ObservableStatus s("id", "fileid");
    std::stringstream ss;
    ss << s;
    EXPECT_THAT(
        ss.str(),
        MatchesRegex("ObservableStatus\\(id='id', file_id='fileid', state=.*, error=false\\)"));
}
 
TEST_F(TestObservableStatus, Observability) {
    // Setup
    InSequence seq;  // Mock expectations must occur in sequence
 
    StatusObserverMock o;
    ObservableStatus s("id", "fileid");
 
    auto time = Status::Clock::now();
 
    s.ConnectObserver(std::reference_wrapper(o));
    EXPECT_CALL(o, CallOperator(Property(&ObservableStatus::GetState, State::Starting)));
    EXPECT_CALL(o, CallOperator(Property(&ObservableStatus::GetState, State::Acquiring)));
    EXPECT_CALL(o, CallOperator(Property(&ObservableStatus::GetTimestamp, time)));
 
    // Test
    s.SetState(State::Starting);
    s.SetState(State::Acquiring);
 
    auto new_status = s.GetStatus();
    new_status.timestamp = time;
    // Assigning complete status which should then use the timestamp from that status.
    s = new_status;
}
 
TEST(TestStatus, OstreamOperator) {
    Status s("id", "fileid");
    // Note that epoch is not really portable so this test may break on non-linux platforms
    s.timestamp = std::chrono::time_point<std::chrono::system_clock>(
        std::chrono::nanoseconds(1693899318896895717));
    std::stringstream ss;
    ss << s;
    EXPECT_THAT(ss.str(),
                MatchesRegex("Status\\(id='id', file_id='fileid', state=.*, error=false, "
                             "result=''\\, timestamp=2023-09-05T07:35:18.896)"));
}
 
TEST(TestStatus, Comparison) {
    Status s1("id", "fileid");
    Status s2("id", "fileid");
    Status s3("id", "fileid");
    EXPECT_FALSE(HasError(s3));
    s3.alerts.push_back(MakeAlert("cat", "key", "description"));
 
    EXPECT_TRUE(HasError(s3));
    EXPECT_EQ(s1, s2);
    EXPECT_NE(s1, s3);
}
 
TEST(TestStatus, Alerts) {
    Status s1("id", "fileid");
    Alert alert = {};
    alert.id.category = "cat";
    alert.id.key = "key";
    alert.description = "description";
 
    SetAlert(s1.alerts, alert);
    ASSERT_EQ(1, s1.alerts.size());
    EXPECT_EQ(s1.alerts[0], alert);
    EXPECT_EQ(s1.alerts[0].description, "description");
 
    auto alert2 = alert;
    alert2.id.key = "different key";
 
    SetAlert(s1.alerts, alert2);
 
    ASSERT_EQ(2, s1.alerts.size());
 
    alert.description = "new description";
    SetAlert(s1.alerts, alert);
    EXPECT_EQ(s1.alerts[0].description, "new description");
 
    // Remove alert1 which leaves alert2
    ClearAlert(s1.alerts, alert.id);
    ASSERT_EQ(1, s1.alerts.size());
    EXPECT_EQ(s1.alerts[0], alert2);
}
 
TEST(TestAlertId, Comparison) {
    AlertId alert1 = {};
    alert1.category = "cat";
    alert1.key = "key";
    EXPECT_EQ(alert1, alert1);
 
    auto alert2 = alert1;
    alert2.key = "different key";
    EXPECT_NE(alert1, alert2);
 
    auto alert3 = alert1;
    alert3.category = "different category";
    EXPECT_NE(alert1, alert3);
}
 
TEST(TestAlert, Comparison) {
    Alert alert1 = {};
    alert1.id.category = "cat";
    alert1.id.key = "key";
    alert1.description = "description";
    EXPECT_EQ(alert1, alert1);
 
    auto alert2 = alert1;
    alert2.id.key = "different key";
    EXPECT_NE(alert1, alert2);
 
    auto alert3 = alert1;
    alert3.id.category = "different category";
    EXPECT_NE(alert1, alert3);
}