test_sch_io_database.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <algorithm>
#include <memory>
#include <set>
#include <vector>
 
#include <qa_utils/wx_utils/unit_test_utils.h>
 
#include <database/database_lib_settings.h>
#include <eda_pattern_match.h>
#include <ki_exception.h>
#include <lib_symbol.h>
#include <libraries/library_manager.h>
#include <libraries/symbol_library_adapter.h>
#include <sch_io/database/sch_io_database.h>
 
 
BOOST_AUTO_TEST_SUITE( SchIoDatabase )
 
 

BOOST_AUTO_TEST_CASE( UnchangedDataReusesCache )
{
    LIBRARY_MANAGER        manager;
    SYMBOL_LIBRARY_ADAPTER adapter( manager );
 
    SCH_IO_DATABASE plugin;
    plugin.SetLibraryManagerAdapter( &adapter );
 
    wxString libPath( QA_DBLIB_SETTINGS_PATH );
 
    std::vector<LIB_SYMBOL*> first;
    BOOST_REQUIRE_NO_THROW( plugin.EnumerateSymbolLib( first, libPath ) );
    BOOST_REQUIRE( !first.empty() );
 
    // Defeat the age throttle so the next call actually re-queries and compares signatures rather
    // than short-circuiting on the cache timestamp.
    plugin.Settings()->m_Cache.max_age = 0;
 
    std::vector<LIB_SYMBOL*> second;
    BOOST_REQUIRE_NO_THROW( plugin.EnumerateSymbolLib( second, libPath ) );
 
    BOOST_REQUIRE_EQUAL( first.size(), second.size() );
 
    std::set<wxString> firstNames;
 
    for( LIB_SYMBOL* symbol : first )
    {
        firstNames.insert( symbol->GetName() );
        delete symbol;
    }
 
    for( LIB_SYMBOL* symbol : second )
    {
        BOOST_CHECK( firstNames.count( symbol->GetName() ) );
        delete symbol;
    }
}
 

BOOST_AUTO_TEST_CASE( FieldMappedDescriptionMatchesShownDescription )
{
    const std::string dblPath =
            KI_TEST::GetTestDataRootDir() + "dblib/qa_dblib_field_description.kicad_dbl";
 
    LIBRARY_MANAGER        manager;
    SYMBOL_LIBRARY_ADAPTER adapter( manager );
 
    SCH_IO_DATABASE plugin;
    plugin.SetLibraryManagerAdapter( &adapter );
 
    LIB_SYMBOL* symbol = nullptr;
 
    try
    {
        symbol = plugin.LoadSymbol( dblPath, wxS( "RES-001" ), nullptr );
    }
    catch( const IO_ERROR& ioe )
    {
        // The database connection needs a working ODBC SQLite driver; skip when it is unavailable
        // so the test does not fail spuriously on minimal CI images.
        BOOST_TEST_MESSAGE( "Skipping: database library unavailable: " + ioe.What().ToStdString() );
        return;
    }
 
    BOOST_REQUIRE( symbol );
 
    std::unique_ptr<LIB_SYMBOL> owned( symbol );
 
    const wxString liveDescription = owned->GetField( FIELD_T::DESCRIPTION )->GetShownText( FOR_GUI );
 
    // The database row for RES-001 carries a non-empty Description.
    BOOST_REQUIRE( !liveDescription.IsEmpty() );
 
    // The chooser tree / search path must agree with the live field the details panel shows.
    BOOST_CHECK_EQUAL( owned->GetShownDescription( FOR_GUI ), liveDescription );
    BOOST_CHECK_EQUAL( owned->GetDesc(), liveDescription );
 
    // The search-term cache feeds chooser filtering and is built from the shown description, so it
    // must reflect the database value too.
    const std::vector<SEARCH_TERM>& terms = owned->GetSearchTerms();
    bool descriptionTermPresent = std::any_of( terms.begin(), terms.end(),
                                               [&]( const SEARCH_TERM& aTerm )
                                               {
                                                   return aTerm.Text == liveDescription;
                                               } );
 
    BOOST_CHECK( descriptionTermPresent );
}
 

BOOST_AUTO_TEST_CASE( CreateConnectionExpandsCwdAndPrefersConnectionString )
{
    const std::string dblPath = KI_TEST::GetTestDataRootDir() + "dblib/qa_dblib_field_description.kicad_dbl";
 
    DATABASE_LIB_SETTINGS settings( dblPath );
    settings.SetReadOnly( true );
    settings.LoadFromFile();
 
    BOOST_REQUIRE( settings.m_Source.connection_string.find( "${CWD}" ) != std::string::npos );
 
    // The database file is only found if ${CWD} became the settings folder
    settings.m_Source.dsn = "qa_nonexistent_dsn";
 
    std::unique_ptr<DATABASE_CONNECTION> conn = SCH_IO_DATABASE::CreateConnection( settings );
 
    BOOST_REQUIRE( conn );
    BOOST_CHECK_MESSAGE( conn->IsConnected(), conn->GetLastError() );
 
    settings.m_Source.connection_string.clear();
    conn = SCH_IO_DATABASE::CreateConnection( settings );
 
    BOOST_REQUIRE( conn );
    BOOST_CHECK( !conn->IsConnected() );
}
 

BOOST_AUTO_TEST_CASE( PreviewSymbolsMatchCachedNames )
{
    LIBRARY_MANAGER        manager;
    SYMBOL_LIBRARY_ADAPTER adapter( manager );
 
    SCH_IO_DATABASE plugin;
    plugin.SetLibraryManagerAdapter( &adapter );
 
    std::vector<LIB_SYMBOL*> listed;
    BOOST_REQUIRE_NO_THROW( plugin.EnumerateSymbolLib( listed, wxString( QA_DBLIB_SETTINGS_PATH ) ) );
 
    std::set<wxString> expected;
 
    for( LIB_SYMBOL* symbol : listed )
    {
        if( symbol->GetName().StartsWith( wxS( "Resistors/" ) ) )
            expected.insert( symbol->GetName() );
 
        delete symbol;
    }
 
    BOOST_REQUIRE( !expected.empty() );
 
    const DATABASE_LIB_SETTINGS& settings = *plugin.Settings();
    auto table = std::find_if( settings.m_Tables.begin(), settings.m_Tables.end(),
                               []( const DATABASE_LIB_TABLE& aTable )
                               {
                                   return aTable.name == "Resistors";
                               } );
    BOOST_REQUIRE( table != settings.m_Tables.end() );
 
    std::unique_ptr<DATABASE_CONNECTION>  conn = SCH_IO_DATABASE::CreateConnection( settings );
    std::vector<std::string>              columns;
    std::vector<DATABASE_CONNECTION::ROW> rows;
    BOOST_REQUIRE( conn->SelectSample( table->table, 100000, columns, rows ) );
 
    std::set<wxString> previewed;
 
    for( const std::unique_ptr<LIB_SYMBOL>& symbol :
         SCH_IO_DATABASE::BuildPreviewSymbols( &adapter, *table, settings.m_GloballyUniqueKeys, rows, nullptr ) )
    {
        previewed.insert( symbol->GetName() );
    }
 
    BOOST_CHECK( previewed == expected );
}
 
 
BOOST_AUTO_TEST_SUITE_END()