Improve MetadataList tests

This commit is contained in:
Oliver Hamlet
2016-04-02 11:48:45 +01:00
parent 06d70e624d
commit 5c8dee547c
4 changed files with 298 additions and 253 deletions
+1 -1
View File
@@ -255,7 +255,7 @@ set (LOOT_TESTS_HEADERS "${CMAKE_SOURCE_DIR}/src/tests/base_game_test.h"
"${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/tag_test.h"
"${CMAKE_SOURCE_DIR}/src/tests/backend/plugin/plugin_test.h"
"${CMAKE_SOURCE_DIR}/src/tests/backend/masterlist_test.h"
"${CMAKE_SOURCE_DIR}/src/tests/backend/test_metadata_list.h"
"${CMAKE_SOURCE_DIR}/src/tests/backend/metadata_list_test.h"
"${CMAKE_SOURCE_DIR}/src/tests/backend/test_plugin_sorter.h"
"${CMAKE_SOURCE_DIR}/src/tests/gui/loot_settings_test.h"
"${CMAKE_SOURCE_DIR}/src/tests/gui/loot_state_test.h")
+296
View File
@@ -0,0 +1,296 @@
/* LOOT
A load order optimisation tool for Oblivion, Skyrim, Fallout 3 and
Fallout: New Vegas.
Copyright (C) 2014-2016 WrinklyNinja
This file is part of LOOT.
LOOT 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 3 of
the License, or (at your option) any later version.
LOOT 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 LOOT. If not, see
<http://www.gnu.org/licenses/>.
*/
#ifndef LOOT_TEST_BACKEND_METADATA_LIST
#define LOOT_TEST_BACKEND_METADATA_LIST
#include "backend/metadata_list.h"
#include "tests/base_game_test.h"
namespace loot {
namespace test {
class MetadataListTest : public BaseGameTest {
protected:
MetadataListTest() :
metadataPath("./testing-metadata/masterlist.yaml"),
savedMetadataPath("./testing-metadata/saved.masterlist.yaml"),
missingMetadataPath("./missing-metadata.yaml"),
invalidMetadataPaths({"./testing-metadata/invalid/non_unique.yaml"}) {
PluginMetadataToString = [](const PluginMetadata& plugin) {
return plugin.Name();
};
}
inline virtual void SetUp() {
BaseGameTest::SetUp();
ASSERT_TRUE(boost::filesystem::exists(metadataPath));
ASSERT_FALSE(boost::filesystem::exists(savedMetadataPath));
for (const auto& path : invalidMetadataPaths) {
ASSERT_TRUE(boost::filesystem::exists(path));
}
}
inline virtual void TearDown() {
BaseGameTest::TearDown();
ASSERT_TRUE(boost::filesystem::exists(metadataPath));
ASSERT_NO_THROW(boost::filesystem::remove(savedMetadataPath));
for (const auto& path : invalidMetadataPaths) {
ASSERT_TRUE(boost::filesystem::exists(path));
}
}
const boost::filesystem::path metadataPath;
const boost::filesystem::path savedMetadataPath;
const boost::filesystem::path missingMetadataPath;
const std::vector<boost::filesystem::path> invalidMetadataPaths;
std::function<std::string(const PluginMetadata&)> PluginMetadataToString;
};
// Pass an empty first argument, as it's a prefix for the test instantation,
// but we only have the one so no prefix is necessary.
INSTANTIATE_TEST_CASE_P(,
MetadataListTest,
::testing::Values(
GameSettings::tes4));
TEST_P(MetadataListTest, loadShouldLoadGlobalMessages) {
MetadataList metadataList;
EXPECT_NO_THROW(metadataList.Load(metadataPath));
EXPECT_EQ(std::list<Message>({
Message(Message::say, "A global message."),
}), metadataList.Messages());
}
TEST_P(MetadataListTest, loadShouldLoadPluginMetadata) {
MetadataList metadataList;
EXPECT_NO_THROW(metadataList.Load(metadataPath));
// Non-regex plugins can be outputted in any order, and regex entries can
// match each other, so convert the list to a set of strings for
// comparison.
std::list<PluginMetadata> result(metadataList.Plugins());
std::set<std::string> names;
std::transform(begin(result),
end(result),
std::insert_iterator<std::set<std::string>>(names, begin(names)),
PluginMetadataToString);
EXPECT_EQ(std::set<std::string>({
blankEsm,
blankEsp,
"Blank.+\\.esp",
"Blank.+(Different)?.*\\.esp",
}), names);
}
TEST_P(MetadataListTest, loadShouldThrowIfAnInvalidMetadataFileIsGiven) {
MetadataList ml;
for (const auto& path : invalidMetadataPaths) {
EXPECT_ANY_THROW(ml.Load(path));
}
}
TEST_P(MetadataListTest, loadShouldClearExistingDataIfAnInvalidMetadataFileIsGiven) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
ASSERT_FALSE(metadataList.Messages().empty());
ASSERT_FALSE(metadataList.Plugins().empty());
EXPECT_ANY_THROW(metadataList.Load(blankEsm));
EXPECT_TRUE(metadataList.Messages().empty());
EXPECT_TRUE(metadataList.Plugins().empty());
}
TEST_P(MetadataListTest, loadShouldClearExistingDataIfAMissingMetadataFileIsGiven) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
ASSERT_FALSE(metadataList.Messages().empty());
ASSERT_FALSE(metadataList.Plugins().empty());
EXPECT_ANY_THROW(metadataList.Load(missingMetadataPath));
EXPECT_TRUE(metadataList.Messages().empty());
EXPECT_TRUE(metadataList.Plugins().empty());
}
TEST_P(MetadataListTest, saveShouldWriteTheLoadedMetadataToTheGivenFilePath) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
EXPECT_NO_THROW(metadataList.Save(savedMetadataPath));
EXPECT_TRUE(boost::filesystem::exists(savedMetadataPath));
// Check the new file contains the same metadata.
EXPECT_NO_THROW(metadataList.Load(savedMetadataPath));
EXPECT_EQ(std::list<Message>({
Message(Message::say, "A global message."),
}), metadataList.Messages());
// Non-regex plugins can be outputted in any order, and regex entries can
// match each other, so convert the list to a set of strings for
// comparison.
std::list<PluginMetadata> result(metadataList.Plugins());
std::set<std::string> names;
std::transform(begin(result),
end(result),
std::insert_iterator<std::set<std::string>>(names, begin(names)),
PluginMetadataToString);
EXPECT_EQ(std::set<std::string>({
blankEsm,
blankEsp,
"Blank.+\\.esp",
"Blank.+(Different)?.*\\.esp",
}), names);
}
TEST_P(MetadataListTest, clearShouldClearLoadedMessagesAndPlugins) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
ASSERT_FALSE(metadataList.Messages().empty());
ASSERT_FALSE(metadataList.Plugins().empty());
metadataList.clear();
EXPECT_TRUE(metadataList.Messages().empty());
EXPECT_TRUE(metadataList.Plugins().empty());
}
TEST_P(MetadataListTest, findPluginShouldReturnAnEmptyPluginObjectIfTheGivenPluginIsNotInTheMetadataList) {
MetadataList metadataList;
PluginMetadata plugin = metadataList.FindPlugin(PluginMetadata(blankDifferentEsm));
EXPECT_EQ(blankDifferentEsm, plugin.Name());
EXPECT_TRUE(plugin.HasNameOnly());
}
TEST_P(MetadataListTest, findPluginShouldReturnTheMetadataObjectInTheMetadataListIfOneExistsForTheGivenPlugin) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
PluginMetadata plugin = metadataList.FindPlugin(PluginMetadata(blankDifferentEsp));
EXPECT_EQ(blankDifferentEsp, plugin.Name());
EXPECT_EQ(std::set<File>({
File(blankEsm),
}), plugin.LoadAfter());
EXPECT_EQ(std::set<File>({
File(blankEsp),
}), plugin.Incs());
}
TEST_P(MetadataListTest, addPluginShouldStoreGivenSpecificPluginMetadata) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
ASSERT_TRUE(metadataList.FindPlugin(PluginMetadata(blankDifferentEsm)).HasNameOnly());
PluginMetadata plugin(blankDifferentEsm);
plugin.Priority(1000);
metadataList.AddPlugin(plugin);
plugin = metadataList.FindPlugin(plugin);
EXPECT_EQ(blankDifferentEsm, plugin.Name());
EXPECT_EQ(1000, plugin.Priority());
}
TEST_P(MetadataListTest, addPluginShouldStoreGivenRegexPluginMetadata) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
PluginMetadata plugin(".+Dependent\\.esp");
plugin.Priority(-10);
metadataList.AddPlugin(plugin);
plugin = metadataList.FindPlugin(PluginMetadata(blankPluginDependentEsp));
EXPECT_EQ(-10, plugin.Priority());
}
TEST_P(MetadataListTest, addPluginShouldThrowIfAMatchingPluginAlreadyExists) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
PluginMetadata plugin = metadataList.FindPlugin(PluginMetadata(blankEsm));
ASSERT_EQ(blankEsm, plugin.Name());
ASSERT_FALSE(plugin.HasNameOnly());
ASSERT_ANY_THROW(metadataList.AddPlugin(PluginMetadata(blankEsm)));
}
TEST_P(MetadataListTest, erasePluginShouldRemoveStoredMetadatForTheGivenPlugin) {
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
PluginMetadata plugin = metadataList.FindPlugin(PluginMetadata(blankEsp));
ASSERT_EQ(blankEsp, plugin.Name());
ASSERT_FALSE(plugin.HasNameOnly());
metadataList.ErasePlugin(plugin);
plugin = metadataList.FindPlugin(plugin);
EXPECT_EQ(blankEsp, plugin.Name());
EXPECT_TRUE(plugin.HasNameOnly());
}
TEST_P(MetadataListTest, evalAllConditionsShouldEvaluateTheConditionsForThePluginsStoredInTeMetadataList) {
Game game(GetParam());
game.SetGamePath(dataPath.parent_path());
ASSERT_NO_THROW(game.Init(false, localPath));
MetadataList metadataList;
ASSERT_NO_THROW(metadataList.Load(metadataPath));
PluginMetadata plugin = metadataList.FindPlugin(PluginMetadata(blankEsm));
ASSERT_EQ(std::list<Message>({
Message(Message::warn, "This is a warning."),
Message(Message::say, "This message should be removed when evaluating conditions."),
}), plugin.Messages());
plugin = metadataList.FindPlugin(PluginMetadata(blankEsp));
ASSERT_EQ(blankEsp, plugin.Name());
ASSERT_FALSE(plugin.HasNameOnly());
EXPECT_NO_THROW(metadataList.EvalAllConditions(game, Language::english));
plugin = metadataList.FindPlugin(PluginMetadata(blankEsm));
EXPECT_EQ(std::list<Message>({
Message(Message::warn, "This is a warning."),
}), plugin.Messages());
plugin = metadataList.FindPlugin(PluginMetadata(blankEsp));
EXPECT_EQ(blankEsp, plugin.Name());
EXPECT_TRUE(plugin.HasNameOnly());
}
}
}
#endif
-251
View File
@@ -1,251 +0,0 @@
/* LOOT
A load order optimisation tool for Oblivion, Skyrim, Fallout 3 and
Fallout: New Vegas.
Copyright (C) 2014-2016 WrinklyNinja
This file is part of LOOT.
LOOT 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 3 of
the License, or (at your option) any later version.
LOOT 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 LOOT. If not, see
<http://www.gnu.org/licenses/>.
*/
#ifndef LOOT_TEST_BACKEND_METADATA_LIST
#define LOOT_TEST_BACKEND_METADATA_LIST
#include "backend/metadata_list.h"
#include "tests/fixtures.h"
namespace loot {
namespace test {
class MetadataListTest : public SkyrimTest {
protected:
MetadataListTest() :
metadataPath("./testing-metadata/masterlist.yaml"),
savedMetadataPath("./testing-metadata/saved.masterlist.yaml"),
invalidMetadataPaths({"./testing-metadata/invalid/non_unique.yaml"}) {
PluginMetadataToString = [](const PluginMetadata& plugin) {
return plugin.Name();
};
}
inline virtual void SetUp() {
SkyrimTest::SetUp();
ASSERT_TRUE(boost::filesystem::exists(metadataPath));
ASSERT_FALSE(boost::filesystem::exists(savedMetadataPath));
for (const auto& path : invalidMetadataPaths) {
ASSERT_TRUE(boost::filesystem::exists(path));
}
}
inline virtual void TearDown() {
SkyrimTest::TearDown();
ASSERT_TRUE(boost::filesystem::exists(metadataPath));
ASSERT_NO_THROW(boost::filesystem::remove(savedMetadataPath));
for (const auto& path : invalidMetadataPaths) {
ASSERT_TRUE(boost::filesystem::exists(path));
}
}
const boost::filesystem::path metadataPath;
const boost::filesystem::path savedMetadataPath;
const std::vector<boost::filesystem::path> invalidMetadataPaths;
std::function<std::string(const PluginMetadata&)> PluginMetadataToString;
};
TEST_F(MetadataListTest, Load) {
MetadataList ml;
EXPECT_NO_THROW(ml.Load(metadataPath));
EXPECT_EQ(std::list<Message>({
Message(Message::say, "A global message."),
}), ml.Messages());
// Non-regex plugins can be outputted in any order, and regex entries can
// match each other, so convert the list to a set of strings for
// comparison.
std::list<PluginMetadata> result(ml.Plugins());
std::set<std::string> names;
std::transform(result.begin(),
result.end(),
std::insert_iterator<std::set<std::string>>(names, names.begin()),
PluginMetadataToString);
EXPECT_EQ(std::set<std::string>({
"Blank.esm",
"Blank.esp",
"Blank.+\\.esp",
"Blank.+(Different)?.*\\.esp",
}), names);
EXPECT_ANY_THROW(ml.Load("NotAPlugin.esm"));
EXPECT_TRUE(ml.Messages().empty());
EXPECT_TRUE(ml.Plugins().empty());
// Fill the list again.
ASSERT_NO_THROW(ml.Load(metadataPath));
EXPECT_ANY_THROW(ml.Load("Blank.missing.esm"));
EXPECT_TRUE(ml.Messages().empty());
EXPECT_TRUE(ml.Plugins().empty());
}
TEST_F(MetadataListTest, Load_Invalid) {
MetadataList ml;
for (const auto& path : invalidMetadataPaths) {
EXPECT_ANY_THROW(ml.Load(path));
}
}
TEST_F(MetadataListTest, Save) {
MetadataList ml;
ASSERT_NO_THROW(ml.Load(metadataPath));
EXPECT_NO_THROW(ml.Save(savedMetadataPath));
EXPECT_TRUE(boost::filesystem::exists(savedMetadataPath));
EXPECT_NO_THROW(ml.Load(savedMetadataPath));
EXPECT_EQ(std::list<Message>({
Message(Message::say, "A global message."),
}), ml.Messages());
// Non-regex plugins can be outputted in any order, and regex entries can
// match each other, so convert the list to a set of strings for
// comparison.
std::list<PluginMetadata> result(ml.Plugins());
std::set<std::string> names;
std::transform(result.begin(),
result.end(),
std::insert_iterator<std::set<std::string>>(names, names.begin()),
PluginMetadataToString);
EXPECT_EQ(std::set<std::string>({
"Blank.esm",
"Blank.esp",
"Blank.+\\.esp",
"Blank.+(Different)?.*\\.esp",
}), names);
}
TEST_F(MetadataListTest, clear) {
MetadataList ml;
ASSERT_NO_THROW(ml.Load(metadataPath));
ASSERT_FALSE(ml.Messages().empty());
ASSERT_FALSE(ml.Plugins().empty());
ml.clear();
EXPECT_TRUE(ml.Messages().empty());
EXPECT_TRUE(ml.Plugins().empty());
}
TEST_F(MetadataListTest, FindPlugin) {
MetadataList ml;
ASSERT_NO_THROW(ml.Load(metadataPath));
PluginMetadata pm = ml.FindPlugin(PluginMetadata("Blank - Different.esm"));
EXPECT_EQ("Blank - Different.esm", pm.Name());
EXPECT_TRUE(pm.HasNameOnly());
pm = ml.FindPlugin(PluginMetadata("Blank - Different.esp"));
EXPECT_EQ("Blank - Different.esp", pm.Name());
EXPECT_EQ(std::set<File>({
File("Blank.esm"),
}), pm.LoadAfter());
EXPECT_EQ(std::set<File>({
File("Blank.esp"),
}), pm.Incs());
}
TEST_F(MetadataListTest, AddPlugin) {
MetadataList ml;
ASSERT_NO_THROW(ml.Load(metadataPath));
PluginMetadata pm = ml.FindPlugin(PluginMetadata("Blank - Different.esm"));
ASSERT_EQ("Blank - Different.esm", pm.Name());
ASSERT_TRUE(pm.HasNameOnly());
pm.Priority(1000);
ml.AddPlugin(pm);
pm = ml.FindPlugin(pm);
EXPECT_EQ("Blank - Different.esm", pm.Name());
EXPECT_EQ(1000, pm.Priority());
pm = PluginMetadata(".+Dependent\\.esp");
pm.Priority(-10);
ml.AddPlugin(pm);
pm = ml.FindPlugin(PluginMetadata("Blank - Plugin Dependent.esp"));
EXPECT_EQ(-10, pm.Priority());
}
TEST_F(MetadataListTest, AddPlugin_NonUnique) {
MetadataList ml;
ASSERT_NO_THROW(ml.Load(metadataPath));
PluginMetadata pm = ml.FindPlugin(PluginMetadata("Blank.esm"));
ASSERT_EQ("Blank.esm", pm.Name());
ASSERT_FALSE(pm.HasNameOnly());
ASSERT_ANY_THROW(ml.AddPlugin(PluginMetadata("Blank.esm")));
}
TEST_F(MetadataListTest, ErasePlugin) {
MetadataList ml;
ASSERT_NO_THROW(ml.Load(metadataPath));
PluginMetadata pm = ml.FindPlugin(PluginMetadata("Blank.esp"));
ASSERT_EQ("Blank.esp", pm.Name());
ASSERT_FALSE(pm.HasNameOnly());
ml.ErasePlugin(pm);
pm = ml.FindPlugin(pm);
ASSERT_EQ("Blank.esp", pm.Name());
ASSERT_TRUE(pm.HasNameOnly());
}
TEST_F(MetadataListTest, EvalAllConditions) {
Game game(Game::tes5);
game.SetGamePath(dataPath.parent_path());
ASSERT_NO_THROW(game.Init(false, localPath));
MetadataList ml;
ASSERT_NO_THROW(ml.Load(metadataPath));
PluginMetadata pm = ml.FindPlugin(PluginMetadata("Blank.esm"));
ASSERT_EQ(std::list<Message>({
Message(Message::warn, "This is a warning."),
Message(Message::say, "This message should be removed when evaluating conditions."),
}), pm.Messages());
pm = ml.FindPlugin(PluginMetadata("Blank.esp"));
ASSERT_EQ("Blank.esp", pm.Name());
ASSERT_FALSE(pm.HasNameOnly());
EXPECT_NO_THROW(ml.EvalAllConditions(game, Language::english));
pm = ml.FindPlugin(PluginMetadata("Blank.esm"));
EXPECT_EQ(std::list<Message>({
Message(Message::warn, "This is a warning."),
}), pm.Messages());
pm = ml.FindPlugin(PluginMetadata("Blank.esp"));
EXPECT_EQ("Blank.esp", pm.Name());
EXPECT_TRUE(pm.HasNameOnly());
}
}
}
#endif
+1 -1
View File
@@ -60,8 +60,8 @@
#include "backend/metadata/plugin_metadata_test.h"
#include "backend/metadata/tag_test.h"
#include "backend/plugin/plugin_test.h"
#include "backend/test_metadata_list.h"
#include "backend/masterlist_test.h"
#include "backend/metadata_list_test.h"
#include "backend/test_plugin_sorter.h"
#include "gui/loot_settings_test.h"
#include "gui/loot_state_test.h"