testStatus.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq_test
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Test daq::Status and daq::ObservableStatus
 */
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <daq/status.hpp>
 
#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");
}
 
TEST_F(TestObservableStatus, Comparison) {
    ObservableStatus s1("id");
    ObservableStatus s2("id");
    ObservableStatus s3("id");
    s3.SetError(true);
    EXPECT_EQ(s1, s2);
    EXPECT_NE(s1, s3);
}
 
TEST_F(TestObservableStatus, State) {
    ObservableStatus s("id");
 
    EXPECT_EQ(State::NotStarted, s.GetState()) << "Default state should be State::NotStarted";
    EXPECT_FALSE(s.GetError()) << "By default error flag should be false";
 
    s.SetState(State::Starting);
    EXPECT_EQ(State::Starting, s.GetState());
}
 
TEST_F(TestObservableStatus, Files) {
    ObservableStatus s("id");
 
    EXPECT_TRUE(s.GetFiles().empty());
 
    std::vector<DpPart> files1{{"origin1", "path1"}, {"origin2", "path2"} };
    std::vector<DpPart> files2{{"origin3", "path3"}};
 
    s.AddFiles(files1);
    EXPECT_FALSE(s.GetFiles().empty());
    EXPECT_EQ(files1, s.GetFiles());
    EXPECT_NE(files2, s.GetFiles());
 
    s.AddFiles(files2);
    EXPECT_NE(files1, s.GetFiles());
 
    auto files3 = files1;
    files3.insert(files3.end(), files2.begin(), files2.end());
    EXPECT_EQ(files3, s.GetFiles());
}
 
TEST_F(TestObservableStatus, Keywords) {
    ObservableStatus s("id");
 
    EXPECT_TRUE(s.GetKeywords().empty());
 
    fits::KeywordVector v;
    s.UpdateKeywords(v);
    EXPECT_TRUE(s.GetKeywords().empty());
 
    v.push_back(fits::EsoKeyword("FOO", "EsoKeyword"));
    s.UpdateKeywords(v);
    EXPECT_EQ(v, s.GetKeywords());
 
    v.push_back(fits::ValueKeyword("FOO", "ValueKeyword"));
    s.UpdateKeywords(v);
    EXPECT_EQ(v, s.GetKeywords()) << "Expected both keywords to be there";
 
    fits::EsoKeyword new_foo = fits::EsoKeyword("FOO", true);
    s.UpdateKeywords({ new_foo });
    v[0] = new_foo;
    EXPECT_EQ(v, s.GetKeywords());
}
 
TEST_F(TestObservableStatus, OstreamOperator) {
    ObservableStatus s("id");
    std::stringstream ss;
    ss << s;
    EXPECT_THAT(ss.str(), MatchesRegex("ObservableStatus\\(id='id', state=.*, error=false\\)"));
}
 
TEST_F(TestObservableStatus, Observability) {
    // Setup
    InSequence seq;  // Mock expectations must occur in sequence
 
    StatusObserverMock o;
    ObservableStatus s("id");
 
    std::vector<DpPart> files = {{"origin1", "path1"}, {"origin2", "path2"}};
 
    s.ConnectObserver(std::reference_wrapper(o));
    EXPECT_CALL(o, CallOperator(AllOf(Property(&ObservableStatus::GetState, State::Starting),
                                      Property(&ObservableStatus::GetFiles, std::vector<DpPart>()))));
    EXPECT_CALL(o, CallOperator(Property(&ObservableStatus::GetFiles, files)));
    EXPECT_CALL(o,
                CallOperator(AllOf(Property(&ObservableStatus::GetState, State::Acquiring),
                                   Property(&ObservableStatus::GetFiles, files))));
 
    // Test
    s.SetState(State::Starting);
    s.AddFiles(files);
    s.SetState(State::Acquiring);
}
 
TEST(TestStatus, OstreamOperator) {
    Status s("id");
    std::stringstream ss;
    ss << s;
    EXPECT_THAT(ss.str(), MatchesRegex("Status\\(id='id', state=.*, error=false\\)"));
}
 
TEST(TestStatus, Comparison) {
    Status s1("id");
    Status s2("id");
    Status s3("id");
    s3.error = true;
    EXPECT_EQ(s1, s2);
    EXPECT_NE(s1, s3);
}