MagAOXApp_test.cpp

Go to the documentation of this file.

// #define CATCH_CONFIG_MAIN
#include "../../../tests/catch2/catch.hpp"
 
#include <mx/sys/timeUtils.hpp>
 
#include "../MagAOXApp.hpp"
 
namespace MagAOXApp_tests
{
 
struct MagAOXApp_test : public MagAOX::app::MagAOXApp<true>
{
    MagAOXApp_test(bool gitmod = false) : MagAOXApp( "sha1", gitmod )
    {
    }
 
    virtual int appStartup()
    {
        return 0;
    }
    virtual int appLogic()
    {
        return 0;
    }
    virtual int appShutdown()
    {
        return 0;
    }
 
    std::string configPathGlobal()
    {
        return MagAOX::app::MagAOXApp<true>::m_configPathGlobal;
    }
 
    std::string configPathUser()
    {
        return MagAOX::app::MagAOXApp<true>::m_configPathUser;
    }
 
    std::string configPathLocal()
    {
        return MagAOX::app::MagAOXApp<true>::m_configPathLocal;
    }
 
    std::string &invokedName()
    {
        return MagAOX::app::MagAOXApp<true>::invokedName;
    }
 
    bool &doHelp()
    {
        return MagAOX::app::MagAOXApp<true>::doHelp;
    }
 
    void setPowerMgtEnabled( bool pme)
    {
        m_powerMgtEnabled = pme;
    }
 
    void setConfigName( const std::string &cn )
    {
        m_configName = cn;
 
        m_indiDriver = new MagAOX::app::indiDriver<MagAOX::app::MagAOXApp<true>>( this, m_configName, "0", "0" );
    }
 
    void setConfigBase( const std::string &cb )
    {
        m_configBase = cb;
    }
 
    int called_back{ 0 };
 
    void doFSMClearAlert()
    {
        pcf::IndiProperty ip(pcf::IndiProperty::Switch);
        ip.setDevice(configName());
        ip.setName("fsm_clear_alert");
        ip.add(pcf::IndiElement("request"));
        ip["request"].setSwitchState(pcf::IndiElement::On);
 
        st_newCallBack_clearFSMAlert(this, ip);
    }
 
};
 
int callback( void *app, const pcf::IndiProperty &ipRecv )
{
    static_cast<void>( ipRecv ); // be unused
 
    MagAOXApp_test *appt = static_cast<MagAOXApp_test *>( app );
 
    appt->called_back = 1;
 
    return 0;
}
 
SCENARIO( "MagAOXApp INDI NewProperty", "[app::MagAOXApp]" )
{
    GIVEN( "a new property request" )
    {
        WHEN( "a wrong device name" )
        {
            MagAOXApp_test app;
 
            app.setConfigName( "test" );
 
            REQUIRE( app.configName() == "test" );
 
            pcf::IndiProperty prop;
            app.registerIndiPropertyNew( prop,
                                         "nprop",
                                         pcf::IndiProperty::Number,
                                         pcf::IndiProperty::ReadWrite,
                                         pcf::IndiProperty::Idle,
                                         callback );
 
            pcf::IndiProperty nprop;
 
            // First test the right device name
            nprop.setDevice( "test" );
            nprop.setName( "nprop" );
 
            app.handleNewProperty( nprop );
 
            REQUIRE( app.called_back == 1 );
 
            app.called_back = 0;
 
            // Now test the wrong device name
            nprop.setDevice( "wrong" );
 
            app.handleNewProperty( nprop );
 
            REQUIRE( app.called_back == 0 );
        }
    }
}
 
TEST_CASE( "Setting defaults", "[app::MagAOXApp]" )
{
    SECTION( "using default paths, configname is invoked name" )
    {
        std::vector<std::string> argvstr( { "./execname" } );
 
        std::vector<const char *> argv( argvstr.size() + 1, NULL );
        for( size_t index = 0; index < argvstr.size(); ++index )
        {
            argv[index] = argvstr[index].c_str();
        }
 
        MagAOXApp_test app;
 
        app.invokedName() = argv[0];
        app.setDefaults( argv.size() - 1, const_cast<char **>( argv.data() ) );
 
        REQUIRE( app.basePath() == MAGAOX_path );
        REQUIRE( app.configDir() == app.basePath() + '/' + MAGAOX_configRelPath );
        REQUIRE( app.configPathGlobal() == app.configDir() + "/magaox.conf" );
        REQUIRE( app.calibDir() == app.basePath() + '/' + MAGAOX_calibRelPath );
        REQUIRE( app.m_log.logPath() == app.basePath() + '/' + MAGAOX_logRelPath );
        REQUIRE( app.sysPath() == app.basePath() + '/' + MAGAOX_sysRelPath );
        REQUIRE( app.secretsPath() == app.basePath() + '/' + MAGAOX_secretsRelPath );
        REQUIRE( app.cpusetPath() == MAGAOX_cpusetPath );
        REQUIRE( app.configBase() == "" );
        REQUIRE( app.configPathUser() == "" );
        REQUIRE( app.configName() == "execname" );
        REQUIRE( app.configPathLocal() == app.configDir() + "/execname.conf" );
 
        REQUIRE( app.doHelp() == true );
    }
 
    SECTION( "using default paths, with config-ed name" )
    {
        std::vector<std::string> argvstr( { "./execname", "-n", "testapp" } );
 
        std::vector<const char *> argv( argvstr.size() + 1, NULL );
        for( size_t index = 0; index < argvstr.size(); ++index )
        {
            argv[index] = argvstr[index].c_str();
        }
 
        MagAOXApp_test app;
        app.invokedName() = argv[0];
 
        app.setDefaults( argv.size() - 1, const_cast<char **>( argv.data() ) );
 
        REQUIRE( app.basePath() == MAGAOX_path );
        REQUIRE( app.configDir() == app.basePath() + '/' + MAGAOX_configRelPath );
        REQUIRE( app.configPathGlobal() == app.configDir() + "/magaox.conf" );
        REQUIRE( app.calibDir() == app.basePath() + '/' + MAGAOX_calibRelPath );
        REQUIRE( app.m_log.logPath() == app.basePath() + '/' + MAGAOX_logRelPath );
 
        REQUIRE( app.sysPath() == app.basePath() + '/' + MAGAOX_sysRelPath );
        REQUIRE( app.secretsPath() == app.basePath() + '/' + MAGAOX_secretsRelPath );
        REQUIRE( app.cpusetPath() == MAGAOX_cpusetPath );
        REQUIRE( app.configBase() == "" );
        REQUIRE( app.configPathUser() == "" );
        REQUIRE( app.configName() == "testapp" );
        REQUIRE( app.configPathLocal() == app.configDir() + "/testapp.conf" );
        REQUIRE( app.doHelp() == false );
    }
 
    // Something goes wrong here, third time is the charm.
    //  Hangs on config.parseCommandLine
    SECTION( "using environment paths, with config-ed name" )
    {
        std::vector<const char *> argv;
        std::vector<std::string>  argvstr( { "./execname", "--name", "testapp2" } );
 
        argv.resize( argvstr.size() + 1, NULL );
        for( size_t index = 0; index < argvstr.size(); ++index )
        {
            argv[index] = argvstr[index].c_str();
        }
 
        char ppath[1024];
        snprintf( ppath, sizeof( ppath ), "%s=/tmp/MagAOXApp_test", MAGAOX_env_path );
        putenv( ppath );
 
        char cpath[1024];
        snprintf( cpath, sizeof( cpath ), "%s=config2", MAGAOX_env_config );
        putenv( cpath );
 
        char cbpath[1024];
        snprintf( cbpath, sizeof( cbpath ), "%s=calib2", MAGAOX_env_calib );
        putenv( cbpath );
 
        char lpath[1024];
        snprintf( lpath, sizeof( lpath ), "%s=logs2", MAGAOX_env_log );
        putenv( lpath );
 
        char syspath[1024];
        snprintf( syspath, sizeof( syspath ), "%s=sys2", MAGAOX_env_sys );
        putenv( syspath );
 
        char secretspath[1024];
        snprintf( secretspath, sizeof( secretspath ), "%s=secrets2", MAGAOX_env_secrets );
        putenv( secretspath );
 
        char cpupath[1024];
        snprintf( cpupath, sizeof( cpupath ), "%s=/tmp/MagAOX/cpuset", MAGAOX_env_cpuset );
        putenv( cpupath );
 
        MagAOXApp_test app;
 
        app.invokedName() = argv[0];
        app.setConfigBase( "cbase" );
 
        app.setDefaults( argv.size() - 1, const_cast<char **>( argv.data() ) );
 
        REQUIRE( app.basePath() == "/tmp/MagAOXApp_test" );
        REQUIRE( app.configDir() == app.basePath() + '/' + "config2" );
        REQUIRE( app.configPathGlobal() == app.configDir() + "/magaox.conf" );
        REQUIRE( app.calibDir() == app.basePath() + '/' + "calib2" );
        REQUIRE( app.m_log.logPath() == app.basePath() + '/' + "logs2" );
        REQUIRE( app.sysPath() == app.basePath() + '/' + "sys2" );
        REQUIRE( app.secretsPath() == app.basePath() + '/' + "secrets2" );
        REQUIRE( app.cpusetPath() == "/tmp/MagAOX/cpuset" );
        REQUIRE( app.configBase() == "cbase" );
        REQUIRE( app.configPathUser() == app.configDir() + "/cbase.conf" );
        REQUIRE( app.configName() == "testapp2" );
        REQUIRE( app.configPathLocal() == app.configDir() + "/testapp2.conf" );
        REQUIRE( app.doHelp() == false );
    }
}
 
TEST_CASE( "Configuring MagAOXApp", "[app::MagAOXApp]" )
{
    SECTION( "setup basic config" )
    {
        MagAOXApp_test app;
        app.setPowerMgtEnabled(true);
 
        app.setupBasicConfig();
 
        REQUIRE(app.shutdown() == false);
    }
 
    SECTION( "load basic config w all defaults w/out pwr management" )
    {
        MagAOXApp_test app;
        app.setPowerMgtEnabled(false);
 
        app.setupBasicConfig();
 
        app.loadBasicConfig();
 
        app.checkConfig();
 
        REQUIRE(app.stateAlert() == false);
        REQUIRE(app.gitAlert() == false);
        REQUIRE(app.shutdown() == false);
 
    }
 
    SECTION( "load basic config w all defaults w/out pwr management, git modified" )
    {
        std::vector<const char *> argv;
        std::vector<std::string>  argvstr( { "./execname", "--name", "testapp" } );
 
        argv.resize( argvstr.size() + 1, NULL );
        for( size_t index = 0; index < argvstr.size(); ++index )
        {
            argv[index] = argvstr[index].c_str();
        }
 
        MagAOXApp_test app(true);
        app.setPowerMgtEnabled(false);
 
        app.setupBasicConfig();
 
        app.setDefaults(argv.size()-1, const_cast<char**>(argv.data()));
 
        app.loadBasicConfig();
 
        app.checkConfig();
 
        REQUIRE(app.stateAlert() == true);
        REQUIRE(app.gitAlert() == true);
        REQUIRE(app.shutdown() == false);
 
 
        app.doFSMClearAlert();
        REQUIRE(app.stateAlert() == false);
        REQUIRE(app.gitAlert() == true);
        REQUIRE(app.shutdown() == false);
 
    }
 
    SECTION( "load basic config w all defaults w unconfigured pwr management" )
    {
        MagAOXApp_test app;
        app.setPowerMgtEnabled(true);
 
        app.setupBasicConfig();
 
        app.loadBasicConfig();
 
        REQUIRE(app.shutdown() == true);
 
        app.checkConfig();
 
        REQUIRE(app.stateAlert() == false);
        REQUIRE(app.gitAlert() == false);
        REQUIRE(app.shutdown() == true);
    }
}
 
} // namespace MagAOXApp_tests