[Settings] Split cache_settings monolith into multiple SettingsManager sub-classes (#7050)

* [Settings] Split cache_settings into multiple files

Took 9 minutes

Took 4 minutes

* [Settings] Fwd declare settings classes in cache_settings

Took 15 minutes

* Fix oracle includes.

Took 8 minutes

* Address comments, fix windows CI

Took 8 minutes

* fix copy constructor visibility

Took 3 minutes

* lint

Took 2 minutes

* Fix native format tests.

Took 5 minutes

* Remove test header guard

Took 4 seconds

* Remove tests invalid in CI environ

Took 24 seconds

* Adjust to rebase.

Took 11 minutes

* Change settings file name.

Took 8 minutes

---------

Co-authored-by: Lukas Brübach <lukas.bruebach@bdosecurity.de>
Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>
This commit is contained in:
BruebachL 2026-07-27 11:25:39 +02:00 committed by GitHub
parent cf0b453e75
commit 12f0f59453
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
166 changed files with 5589 additions and 3066 deletions

View file

@ -87,3 +87,4 @@ add_subdirectory(carddatabase)
add_subdirectory(loading_from_clipboard)
add_subdirectory(movecard_tests)
add_subdirectory(oracle)
add_subdirectory(settings)

View file

@ -0,0 +1,26 @@
add_executable(settings_manager_test settings_manager_test.cpp)
add_executable(settings_defaults_test settings_defaults_test.cpp)
add_executable(settings_migration_test settings_migration_test.cpp)
target_link_libraries(
settings_manager_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
)
target_link_libraries(
settings_defaults_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
)
target_compile_definitions(settings_defaults_test PRIVATE SETTINGS_UNIT_TEST)
target_link_libraries(
settings_migration_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
)
add_test(NAME settings_manager_test COMMAND settings_manager_test)
add_test(NAME settings_defaults_test COMMAND settings_defaults_test)
add_test(NAME settings_migration_test COMMAND settings_migration_test)
if(NOT GTEST_FOUND)
add_dependencies(settings_manager_test gtest)
add_dependencies(settings_defaults_test gtest)
add_dependencies(settings_migration_test gtest)
endif()

View file

@ -0,0 +1,355 @@
#include "gtest/gtest.h"
#include <QSettings>
#include <QTemporaryDir>
#include <libcockatrice/settings/cache_storage_settings.h>
#include <libcockatrice/settings/chat_settings.h>
#include <libcockatrice/settings/game_settings.h>
#include <libcockatrice/settings/personal_settings.h>
#include <libcockatrice/settings/sound_settings.h>
#include <libcockatrice/settings/tabs_settings.h>
#include <libcockatrice/settings/updates_settings.h>
#include <libcockatrice/settings/visual_deck_storage_settings.h>
namespace
{
class SettingsDefaultsTest : public ::testing::Test
{
protected:
QTemporaryDir tempDir;
QString settingsPath;
void SetUp() override
{
settingsPath = tempDir.path() + "/";
}
};
// --- CacheStorageSettings ---
TEST_F(SettingsDefaultsTest, CacheStorage_PixmapCacheSize_Default)
{
CacheStorageSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getPixmapCacheSize(), PIXMAPCACHE_SIZE_DEFAULT);
}
TEST_F(SettingsDefaultsTest, CacheStorage_PixmapCacheSize_SetAndGet)
{
CacheStorageSettings s(settingsPath, nullptr);
s.setPixmapCacheSize(1024);
ASSERT_EQ(s.getPixmapCacheSize(), 1024);
}
TEST_F(SettingsDefaultsTest, CacheStorage_NetworkCacheSizeInMB_Default)
{
CacheStorageSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getNetworkCacheSizeInMB(), NETWORK_CACHE_SIZE_DEFAULT);
}
TEST_F(SettingsDefaultsTest, CacheStorage_RedirectCacheTtl_Default)
{
CacheStorageSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getRedirectCacheTtl(), NETWORK_REDIRECT_CACHE_TTL_DEFAULT);
}
TEST_F(SettingsDefaultsTest, CacheStorage_CardPictureLoaderCacheMethod_Default)
{
CacheStorageSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getCardPictureLoaderCacheMethod(), 0);
}
TEST_F(SettingsDefaultsTest, CacheStorage_LocalCardImageStorageNamingScheme_Default)
{
CacheStorageSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getLocalCardImageStorageNamingScheme(), LOCAL_CARD_IMAGE_NAMING_SCHEME_DEFAULT);
}
// --- GameSettings ---
TEST_F(SettingsDefaultsTest, Game_MaxPlayers_Default)
{
GameSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getMaxPlayers(), 2);
}
TEST_F(SettingsDefaultsTest, Game_MaxPlayers_SetAndGet)
{
GameSettings s(settingsPath, nullptr);
s.setMaxPlayers(4);
ASSERT_EQ(s.getMaxPlayers(), 4);
}
TEST_F(SettingsDefaultsTest, Game_DefaultStartingLifeTotal_Default)
{
GameSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getDefaultStartingLifeTotal(), 20);
}
TEST_F(SettingsDefaultsTest, Game_RememberGameSettings_Default)
{
GameSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getRememberGameSettings(), true);
}
TEST_F(SettingsDefaultsTest, Game_LocalGameMaxPlayers_Default)
{
GameSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getLocalGameMaxPlayers(), 1);
}
TEST_F(SettingsDefaultsTest, Game_LocalGameStartingLifeTotal_Default)
{
GameSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getLocalGameStartingLifeTotal(), 20);
}
TEST_F(SettingsDefaultsTest, Game_LocalGameRememberSettings_Default)
{
GameSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getLocalGameRememberSettings(), false);
}
// --- UpdatesSettings ---
TEST_F(SettingsDefaultsTest, Updates_CheckUpdatesOnStartup_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getCheckUpdatesOnStartup(), true);
}
TEST_F(SettingsDefaultsTest, Updates_StartupCardUpdateCheckPromptForUpdate_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getStartupCardUpdateCheckPromptForUpdate(), true);
}
TEST_F(SettingsDefaultsTest, Updates_StartupCardUpdateCheckAlwaysUpdate_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getStartupCardUpdateCheckAlwaysUpdate(), false);
}
TEST_F(SettingsDefaultsTest, Updates_CardUpdateCheckInterval_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getCardUpdateCheckInterval(), 7);
}
TEST_F(SettingsDefaultsTest, Updates_AlwaysEnableNewSets_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getAlwaysEnableNewSets(), false);
}
TEST_F(SettingsDefaultsTest, Updates_NotifyAboutUpdates_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getNotifyAboutUpdates(), true);
}
TEST_F(SettingsDefaultsTest, Updates_NotifyAboutNewVersion_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getNotifyAboutNewVersion(), true);
}
TEST_F(SettingsDefaultsTest, Updates_UpdateReleaseChannelIndex_Default)
{
UpdatesSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getUpdateReleaseChannelIndex(), 0);
}
// --- SoundSettings ---
TEST_F(SettingsDefaultsTest, Sound_SoundEnabled_Default)
{
SoundSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getSoundEnabled(), false);
}
TEST_F(SettingsDefaultsTest, Sound_MasterVolume_Default)
{
SoundSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getMasterVolume(), 100);
}
TEST_F(SettingsDefaultsTest, Sound_MasterVolume_SetAndGet)
{
SoundSettings s(settingsPath, nullptr);
s.setMasterVolume(50);
ASSERT_EQ(s.getMasterVolume(), 50);
}
// --- TabsSettings ---
TEST_F(SettingsDefaultsTest, Tabs_AllTabsOpen_Default)
{
TabsSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getTabVisualDeckStorageOpen(), true);
ASSERT_EQ(s.getTabServerOpen(), true);
ASSERT_EQ(s.getTabAccountOpen(), true);
ASSERT_EQ(s.getTabDeckStorageOpen(), true);
ASSERT_EQ(s.getTabReplaysOpen(), true);
ASSERT_EQ(s.getTabAdminOpen(), true);
ASSERT_EQ(s.getTabLogOpen(), true);
}
// --- ChatSettings ---
TEST_F(SettingsDefaultsTest, Chat_Mention_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getChatMention(), true);
}
TEST_F(SettingsDefaultsTest, Chat_MentionCompleter_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getChatMentionCompleter(), true);
}
TEST_F(SettingsDefaultsTest, Chat_MentionColor_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getChatMentionColor(), QString("A6120D"));
}
TEST_F(SettingsDefaultsTest, Chat_HighlightColor_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getChatHighlightColor(), QString("A6120D"));
}
TEST_F(SettingsDefaultsTest, Chat_MentionForeground_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getChatMentionForeground(), true);
}
TEST_F(SettingsDefaultsTest, Chat_HighlightForeground_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getChatHighlightForeground(), true);
}
TEST_F(SettingsDefaultsTest, Chat_ShowMessagePopup_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getShowMessagePopup(), true);
}
TEST_F(SettingsDefaultsTest, Chat_ShowMentionPopup_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getShowMentionPopup(), true);
}
TEST_F(SettingsDefaultsTest, Chat_RoomHistory_Default)
{
ChatSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getRoomHistory(), true);
}
// --- PersonalSettings ---
TEST_F(SettingsDefaultsTest, Personal_Lang_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getLang(), QString(""));
}
TEST_F(SettingsDefaultsTest, Personal_ClientID_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getClientID(), QString("notset"));
}
TEST_F(SettingsDefaultsTest, Personal_KeepAlive_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getKeepAlive(), 3);
}
TEST_F(SettingsDefaultsTest, Personal_TimeOut_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getTimeOut(), 5);
}
TEST_F(SettingsDefaultsTest, Personal_PicDownload_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getPicDownload(), true);
}
TEST_F(SettingsDefaultsTest, Personal_ShowStatusBar_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getShowStatusBar(), false);
}
TEST_F(SettingsDefaultsTest, Personal_MaxFontSize_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getMaxFontSize(), 12);
}
TEST_F(SettingsDefaultsTest, Personal_HomeTabBackgroundSource_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getHomeTabBackgroundSource(), QString("themed"));
}
TEST_F(SettingsDefaultsTest, Personal_HomeTabDisplayCardName_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getHomeTabDisplayCardName(), true);
}
TEST_F(SettingsDefaultsTest, Personal_ShowTipsOnStartup_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getShowTipsOnStartup(), true);
}
TEST_F(SettingsDefaultsTest, Personal_DownloadSpoilersStatus_Default)
{
PersonalSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getDownloadSpoilersStatus(), false);
}
// --- VisualDeckStorageSettings ---
TEST_F(SettingsDefaultsTest, VisualDeckStorage_SortingOrder_Default)
{
VisualDeckStorageSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getVisualDeckStorageSortingOrder(), 0);
}
TEST_F(SettingsDefaultsTest, VisualDeckStorage_ShowFolders_Default)
{
VisualDeckStorageSettings s(settingsPath, nullptr);
ASSERT_EQ(s.getVisualDeckStorageShowFolders(), true);
}
TEST_F(SettingsDefaultsTest, VisualDeckStorage_DefaultTagsList_NotEmpty)
{
VisualDeckStorageSettings s(settingsPath, nullptr);
ASSERT_GT(s.getVisualDeckStorageDefaultTagsList().size(), 0);
}
TEST_F(SettingsDefaultsTest, VisualDeckStorage_DefaultTagsList_SetAndGet)
{
VisualDeckStorageSettings s(settingsPath, nullptr);
QStringList custom = {"Tag1", "Tag2"};
s.setVisualDeckStorageDefaultTagsList(custom);
ASSERT_EQ(s.getVisualDeckStorageDefaultTagsList(), custom);
}
} // namespace
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

View file

@ -0,0 +1,171 @@
#include "gtest/gtest.h"
#include <QSettings>
#include <QTemporaryDir>
#include <libcockatrice/settings/settings_manager.h>
namespace
{
class SettingsManagerTest : public ::testing::Test
{
protected:
QTemporaryDir tempDir;
QString settingsPath;
void SetUp() override
{
settingsPath = tempDir.path() + "/";
}
void writeValue(const QString &file, const QString &key, const QVariant &value)
{
QSettings qs(file, QSettings::IniFormat);
qs.setValue(key, value);
}
};
TEST_F(SettingsManagerTest, GetValueNoDefaultReturnsInvalid)
{
SettingsManager sm(settingsPath + "test.ini");
QVariant val = sm.getValue("nonexistent");
ASSERT_TRUE(val.isNull());
}
TEST_F(SettingsManagerTest, GetValueWithDefaultReturnsDefaultWhenMissing)
{
SettingsManager sm(settingsPath + "test.ini");
QVariant val = sm.getValue("nonexistent", QString(), QString(), 42);
ASSERT_EQ(val.toInt(), 42);
}
TEST_F(SettingsManagerTest, GetValueWithDefaultReturnsStoredWhenPresent)
{
writeValue(settingsPath + "test.ini", "mykey", 99);
SettingsManager sm(settingsPath + "test.ini");
QVariant val = sm.getValue("mykey", QString(), QString(), 42);
ASSERT_EQ(val.toInt(), 99);
}
TEST_F(SettingsManagerTest, GetValueWithGroup)
{
writeValue(settingsPath + "grouped.ini", "group1/greeting", "world");
SettingsManager sm(settingsPath + "grouped.ini");
QVariant val = sm.getValue("greeting", "group1");
ASSERT_EQ(val.toString(), QString("world"));
}
TEST_F(SettingsManagerTest, GetValueWithGroupAndSubGroup)
{
writeValue(settingsPath + "nested.ini", "outer/inner/depth", 1);
SettingsManager sm(settingsPath + "nested.ini");
QVariant val = sm.getValue("depth", "outer", "inner");
ASSERT_EQ(val.toInt(), 1);
}
TEST_F(SettingsManagerTest, DefaultGroupUsedInGetValue)
{
writeValue(settingsPath + "defgroup.ini", "defaultGroup/key", "val");
SettingsManager sm(settingsPath + "defgroup.ini", "defaultGroup");
QVariant val = sm.getValue("key");
ASSERT_EQ(val.toString(), QString("val"));
}
TEST_F(SettingsManagerTest, DefaultGroupScopesGetValue)
{
writeValue(settingsPath + "scoped.ini", "key", "ungrouped");
writeValue(settingsPath + "scoped.ini", "defaultGroup/key", "grouped");
SettingsManager sm(settingsPath + "scoped.ini", "defaultGroup");
QVariant val = sm.getValue("key");
ASSERT_EQ(val.toString(), QString("grouped"));
}
TEST_F(SettingsManagerTest, DefaultSubGroupUsedInGetValue)
{
writeValue(settingsPath + "sub.ini", "top/bottom/key", "nested");
SettingsManager sm(settingsPath + "sub.ini", "top", "bottom");
QVariant val = sm.getValue("key");
ASSERT_EQ(val.toString(), QString("nested"));
}
TEST_F(SettingsManagerTest, BatchWriteWritesAllValues)
{
SettingsManager sm(settingsPath + "batch.ini");
sm.batchWrite([&](QSettings &qs) {
qs.setValue("a", 1);
qs.setValue("b", 2);
qs.setValue("c", 3);
});
SettingsManager sm2(settingsPath + "batch.ini");
ASSERT_EQ(sm2.getValue("a", QString(), QString(), 0).toInt(), 1);
ASSERT_EQ(sm2.getValue("b", QString(), QString(), 0).toInt(), 2);
ASSERT_EQ(sm2.getValue("c", QString(), QString(), 0).toInt(), 3);
}
TEST_F(SettingsManagerTest, BatchWriteWithGroup)
{
SettingsManager sm(settingsPath + "batch_group.ini");
sm.batchWrite([&](QSettings &qs) {
qs.beginGroup("section");
qs.setValue("x", 10);
qs.endGroup();
});
SettingsManager sm2(settingsPath + "batch_group.ini");
ASSERT_EQ(sm2.getValue("x", "section", QString(), 0).toInt(), 10);
}
TEST_F(SettingsManagerTest, SyncPersistsToDisk)
{
QString filePath = settingsPath + "sync_test.ini";
{
SettingsManager sm(filePath);
sm.batchWrite([&](QSettings &qs) { qs.setValue("persist", "yes"); });
}
{
QSettings qs(filePath, QSettings::IniFormat);
ASSERT_EQ(qs.value("persist").toString(), QString("yes"));
}
}
TEST_F(SettingsManagerTest, MultipleReadsAfterWrite)
{
SettingsManager sm(settingsPath + "multi.ini");
sm.batchWrite([&](QSettings &qs) { qs.setValue("k1", 1); });
QVariant v1 = sm.getValue("k1", QString(), QString(), 0);
QVariant v2 = sm.getValue("nonexistent", QString(), QString(), 99);
ASSERT_EQ(v1.toInt(), 1);
ASSERT_EQ(v2.toInt(), 99);
}
TEST_F(SettingsManagerTest, ValuesDeletedViaQSettingsAreReadAsDefault)
{
writeValue(settingsPath + "del.ini", "deleteMe", "present");
SettingsManager sm(settingsPath + "del.ini");
ASSERT_EQ(sm.getValue("deleteMe", QString(), QString(), "default").toString(), QString("present"));
// Delete via QSettings directly (deleteValue is protected)
{
QSettings qs(settingsPath + "del.ini", QSettings::IniFormat);
qs.remove("deleteMe");
}
ASSERT_EQ(sm.getValue("deleteMe", QString(), QString(), "default").toString(), QString("default"));
}
} // namespace
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

View file

@ -0,0 +1,413 @@
#include "gtest/gtest.h"
#include <QCoreApplication>
#include <QDir>
#include <QFile>
#include <QSettings>
#include <QStringList>
#include <QTemporaryDir>
#include <libcockatrice/settings/settings_migration.h>
namespace
{
static bool nativeSettingsAvailable()
{
QSettings probe;
probe.setValue("_migration_native_probe", "ok");
probe.sync();
QSettings read;
bool ok = read.value("_migration_native_probe").toString() == "ok";
QSettings().clear();
QSettings().sync();
return ok;
}
class SettingsMigrationTest : public ::testing::Test
{
protected:
QTemporaryDir tempDir;
QString settingsPath;
void SetUp() override
{
settingsPath = tempDir.path() + "/";
}
bool fileExists(const QString &name) const
{
return QFile::exists(settingsPath + name);
}
QVariant readFromIni(const QString &fileName, const QString &key) const
{
QSettings ini(settingsPath + fileName, QSettings::IniFormat);
return ini.value(key);
}
};
TEST_F(SettingsMigrationTest, NoGlobalIniDoesNothing)
{
bool result = SettingsMigration::migrateSettingsFromGlobalIni(settingsPath);
ASSERT_FALSE(result);
}
TEST_F(SettingsMigrationTest, EmptyGlobalIniGetsBackedUp)
{
{
QFile f(settingsPath + "global.ini");
ASSERT_TRUE(f.open(QIODevice::WriteOnly));
f.close();
}
bool result = SettingsMigration::migrateSettingsFromGlobalIni(settingsPath);
ASSERT_TRUE(result);
ASSERT_TRUE(fileExists("global.ini.old"));
ASSERT_TRUE(fileExists("global.ini"));
// No per-file INIs should be created
ASSERT_FALSE(fileExists("tabs.ini"));
ASSERT_FALSE(fileExists("sound.ini"));
// Sentinel should be in the new global.ini
ASSERT_EQ(readFromIni("global.ini", "migration/perfile_complete"), QVariant(true));
}
TEST_F(SettingsMigrationTest, MigratesAllSettingsGroups)
{
{
QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
// tabs
g.setValue("tabs/visualDeckStorage", false);
g.setValue("tabs/server", true);
g.setValue("tabs/account", true);
g.setValue("tabs/deckStorage", true);
g.setValue("tabs/replays", false);
g.setValue("tabs/admin", false);
g.setValue("tabs/log", true);
// sound
g.setValue("sound/enabled", true);
g.setValue("sound/theme", "custom_theme");
g.setValue("sound/mastervolume", 75);
// game
g.beginGroup("game");
g.setValue("maxplayers", 4);
g.setValue("gamedescription", "test game");
g.setValue("remembergamesettings", false);
g.endGroup();
// localgameoptions
g.beginGroup("localgameoptions");
g.setValue("maxplayers", 2);
g.setValue("startinglifetotal", 40);
g.endGroup();
// chat
g.beginGroup("chat");
g.setValue("mention", false);
g.setValue("mentioncolor", "FF0000");
g.setValue("showmessagepopups", false);
g.endGroup();
// cache storage (under [personal] group)
g.setValue("personal/pixmapCacheSize", 1024);
g.setValue("personal/networkCacheSize", 2048);
// updates (under [personal] group)
g.setValue("personal/startupUpdateCheck", false);
g.setValue("personal/cardUpdateCheckInterval", 14);
// personal
g.setValue("personal/lang", "de");
g.setValue("personal/keepalive", 10);
g.setValue("personal/timeout", 30);
g.setValue("personal/clientid", "test-client-id");
g.setValue("personal/picturedownload", true);
g.setValue("personal/showStatusBar", true);
// personal home
g.setValue("home/background", "custom_bg");
g.setValue("home/background/shuffleTimer", 30);
// personal tipOfDay
g.setValue("tipOfDay/showTips", false);
// cards
g.setValue("cards/displaycardnames", false);
g.setValue("cards/tapanimation", true);
g.setValue("cards/scaleCards", false);
// interface
g.setValue("interface/usetearoffmenus", true);
g.setValue("interface/notificationsenabled", false);
g.setValue("interface/startinghandsize", 5);
// hand/table
g.setValue("hand/horizontal", true);
g.setValue("table/invert_vertical", true);
// paths
g.beginGroup("paths");
g.setValue("decks", "/custom/decks");
g.setValue("pics", "/custom/pics");
g.endGroup();
// visual deck storage (under [interface] group)
g.setValue("interface/visualdeckstoragecardsize", 150);
g.setValue("interface/visualdeckstorageshowfolders", false);
g.setValue("interface/visualdeckstorageshowtagfilter", false);
g.sync();
}
bool result = SettingsMigration::migrateSettingsFromGlobalIni(settingsPath);
ASSERT_TRUE(result);
// Original global.ini should be backed up
ASSERT_TRUE(fileExists("global.ini.old"));
// Verify each per-file INI was created and has correct values
ASSERT_TRUE(fileExists("tabs.ini"));
ASSERT_EQ(readFromIni("tabs.ini", "tabs/visualDeckStorage"), QVariant(false));
ASSERT_EQ(readFromIni("tabs.ini", "tabs/server"), QVariant(true));
ASSERT_EQ(readFromIni("tabs.ini", "tabs/log"), QVariant(true));
ASSERT_TRUE(fileExists("sound.ini"));
ASSERT_EQ(readFromIni("sound.ini", "sound/enabled"), QVariant(true));
ASSERT_EQ(readFromIni("sound.ini", "sound/theme"), QVariant("custom_theme"));
ASSERT_EQ(readFromIni("sound.ini", "sound/mastervolume"), QVariant(75));
ASSERT_TRUE(fileExists("game.ini"));
ASSERT_EQ(readFromIni("game.ini", "game/maxplayers"), QVariant(4));
ASSERT_EQ(readFromIni("game.ini", "game/gamedescription"), QVariant("test game"));
ASSERT_EQ(readFromIni("game.ini", "game/remembergamesettings"), QVariant(false));
ASSERT_EQ(readFromIni("game.ini", "localgameoptions/maxplayers"), QVariant(2));
ASSERT_EQ(readFromIni("game.ini", "localgameoptions/startinglifetotal"), QVariant(40));
ASSERT_TRUE(fileExists("chat.ini"));
ASSERT_EQ(readFromIni("chat.ini", "chat/mention"), QVariant(false));
ASSERT_EQ(readFromIni("chat.ini", "chat/mentioncolor"), QVariant("FF0000"));
ASSERT_EQ(readFromIni("chat.ini", "chat/showmessagepopups"), QVariant(false));
ASSERT_TRUE(fileExists("cache_storage.ini"));
ASSERT_EQ(readFromIni("cache_storage.ini", "personal/pixmapCacheSize"), QVariant(1024));
ASSERT_EQ(readFromIni("cache_storage.ini", "personal/networkCacheSize"), QVariant(2048));
ASSERT_TRUE(fileExists("updates.ini"));
ASSERT_EQ(readFromIni("updates.ini", "updates/startupUpdateCheck"), QVariant(false));
ASSERT_EQ(readFromIni("updates.ini", "updates/cardUpdateCheckInterval"), QVariant(14));
ASSERT_TRUE(fileExists("personal.ini"));
ASSERT_EQ(readFromIni("personal.ini", "personal/lang"), QVariant("de"));
ASSERT_EQ(readFromIni("personal.ini", "personal/keepalive"), QVariant(10));
ASSERT_EQ(readFromIni("personal.ini", "personal/clientid"), QVariant("test-client-id"));
ASSERT_EQ(readFromIni("personal.ini", "personal/showStatusBar"), QVariant(true));
ASSERT_EQ(readFromIni("personal.ini", "home/background"), QVariant("custom_bg"));
ASSERT_EQ(readFromIni("personal.ini", "tipOfDay/showTips"), QVariant(false));
ASSERT_TRUE(fileExists("cards_display.ini"));
ASSERT_EQ(readFromIni("cards_display.ini", "cards/displaycardnames"), QVariant(false));
ASSERT_EQ(readFromIni("cards_display.ini", "cards/tapanimation"), QVariant(true));
ASSERT_TRUE(fileExists("interface.ini"));
ASSERT_EQ(readFromIni("interface.ini", "interface/usetearoffmenus"), QVariant(true));
ASSERT_EQ(readFromIni("interface.ini", "interface/notificationsenabled"), QVariant(false));
ASSERT_EQ(readFromIni("interface.ini", "interface/startinghandsize"), QVariant(5));
ASSERT_EQ(readFromIni("interface.ini", "hand/horizontal"), QVariant(true));
ASSERT_EQ(readFromIni("interface.ini", "table/invert_vertical"), QVariant(true));
ASSERT_TRUE(fileExists("paths.ini"));
ASSERT_EQ(readFromIni("paths.ini", "paths/decks"), QVariant("/custom/decks"));
ASSERT_EQ(readFromIni("paths.ini", "paths/pics"), QVariant("/custom/pics"));
ASSERT_TRUE(fileExists("visual_deck_storage.ini"));
ASSERT_EQ(readFromIni("visual_deck_storage.ini", "interface/visualdeckstoragecardsize"), QVariant(150));
ASSERT_EQ(readFromIni("visual_deck_storage.ini", "interface/visualdeckstorageshowfolders"), QVariant(false));
// Verify sentinel was written
ASSERT_EQ(readFromIni("global.ini", "migration/perfile_complete"), QVariant(true));
}
TEST_F(SettingsMigrationTest, SecondCallDoesNothing)
{
{
QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
g.setValue("tabs/visualDeckStorage", true);
g.setValue("sound/enabled", true);
g.sync();
}
ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
ASSERT_FALSE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
}
TEST_F(SettingsMigrationTest, SecondCallDoesNotOverwriteUserChanges)
{
{
QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
g.setValue("tabs/visualDeckStorage", true);
g.setValue("sound/enabled", true);
g.sync();
}
ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
// User changes the value after migration
{
QSettings tabsIni(settingsPath + "tabs.ini", QSettings::IniFormat);
tabsIni.setValue("tabs/visualDeckStorage", false);
tabsIni.sync();
}
// Second migration should NOT overwrite the user's change
ASSERT_FALSE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
ASSERT_EQ(readFromIni("tabs.ini", "tabs/visualDeckStorage"), QVariant(false));
}
TEST_F(SettingsMigrationTest, PartialMigrationOnlyMigratesPresentKeys)
{
{
QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
g.setValue("tabs/visualDeckStorage", true);
g.setValue("tabs/server", false);
g.sync();
}
ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
ASSERT_TRUE(fileExists("global.ini.old"));
ASSERT_TRUE(fileExists("tabs.ini"));
ASSERT_EQ(readFromIni("tabs.ini", "tabs/visualDeckStorage"), QVariant(true));
ASSERT_EQ(readFromIni("tabs.ini", "tabs/server"), QVariant(false));
// Other files should NOT exist since no keys were present for them
ASSERT_FALSE(fileExists("sound.ini"));
ASSERT_FALSE(fileExists("game.ini"));
ASSERT_FALSE(fileExists("chat.ini"));
}
TEST_F(SettingsMigrationTest, KeyMapTranslationIsCorrect)
{
{
QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
g.setValue("personal/cardUpdateCheckInterval", 30);
g.setValue("personal/updatereleasechannel", 1);
g.sync();
}
ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
ASSERT_TRUE(fileExists("global.ini.old"));
ASSERT_TRUE(fileExists("updates.ini"));
// The key should be translated from "personal/cardUpdateCheckInterval" to "updates/cardUpdateCheckInterval"
ASSERT_EQ(readFromIni("updates.ini", "updates/cardUpdateCheckInterval"), QVariant(30));
ASSERT_EQ(readFromIni("updates.ini", "updates/updatereleasechannel"), QVariant(1));
}
TEST_F(SettingsMigrationTest, CardsKeysKeepGroupPrefix)
{
{
QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
g.setValue("cards/displaycardnames", false);
g.setValue("interface/deckeditorbannercardcomboboxvisible", true);
g.sync();
}
ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
ASSERT_TRUE(fileExists("global.ini.old"));
ASSERT_TRUE(fileExists("cards_display.ini"));
// "cards/displaycardnames" should be stored with its group prefix
ASSERT_EQ(readFromIni("cards_display.ini", "cards/displaycardnames"), QVariant(false));
// "interface/..." keys should keep their full path
ASSERT_EQ(readFromIni("cards_display.ini", "interface/deckeditorbannercardcomboboxvisible"), QVariant(true));
}
TEST_F(SettingsMigrationTest, LegacyMigrationIsIdempotent)
{
if (!nativeSettingsAvailable()) {
GTEST_SKIP() << "NativeFormat QSettings not available in this environment";
}
{
QSettings nativeSettings;
nativeSettings.setValue("server/previoushostlogin", "test_user");
nativeSettings.setValue("server/auto_connect", true);
nativeSettings.sync();
}
ASSERT_TRUE(SettingsMigration::migrateLegacySettings(settingsPath));
// Change the migrated value
{
QSettings serversIni(settingsPath + "servers.ini", QSettings::IniFormat);
serversIni.setValue("server/previoushostlogin", "modified_user");
serversIni.sync();
}
// Second migration should NOT overwrite the change
ASSERT_FALSE(SettingsMigration::migrateLegacySettings(settingsPath));
ASSERT_EQ(readFromIni("servers.ini", "server/previoushostlogin"), QVariant("modified_user"));
}
TEST_F(SettingsMigrationTest, LegacyMigrationEmptyNativeFormatWritesSentinel)
{
ASSERT_TRUE(SettingsMigration::migrateLegacySettings(settingsPath));
ASSERT_TRUE(fileExists("personal.ini"));
ASSERT_EQ(readFromIni("personal.ini", "migration/legacy_complete"), QVariant(true));
ASSERT_FALSE(fileExists("messages.ini"));
ASSERT_FALSE(fileExists("gamefilters.ini"));
ASSERT_FALSE(fileExists("cardDatabase.ini"));
// Second call should be a no-op
ASSERT_FALSE(SettingsMigration::migrateLegacySettings(settingsPath));
}
// --- migrateSettingsFromGlobalIni rename-failure test ---
TEST_F(SettingsMigrationTest, RenameFailureWithExistingBackup)
{
{
QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
g.setValue("tabs/visualDeckStorage", true);
g.setValue("sound/enabled", true);
g.sync();
}
// Create a stale backup
{
QFile oldBackup(settingsPath + "global.ini.old");
ASSERT_TRUE(oldBackup.open(QIODevice::WriteOnly));
oldBackup.close();
}
// Migration should still succeed
ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
// Per-file INIs should be created
ASSERT_TRUE(fileExists("tabs.ini"));
ASSERT_TRUE(fileExists("sound.ini"));
// Sentinel should be set in the new global.ini
ASSERT_EQ(readFromIni("global.ini", "migration/perfile_complete"), QVariant(true));
// Original data should be backed up (stale backup was replaced)
ASSERT_TRUE(fileExists("global.ini.old"));
ASSERT_EQ(readFromIni("global.ini.old", "tabs/visualDeckStorage"), QVariant(true));
// Second call should be a no-op
ASSERT_FALSE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
}
} // namespace
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
QCoreApplication app(argc, argv);
app.setOrganizationName("CockatriceTest");
app.setApplicationName("SettingsMigrationTest");
return RUN_ALL_TESTS();
}