loot/libloot
0
0
Fork 0
mirror of https://github.com/loot/libloot.git synced 2026-07-27 14:16:01 -07:00
Code Issues Packages Projects Releases Wiki Activity

Use std::filesystem::path to represent paths in the API

Browse Source
This commit is contained in:
Oliver Hamlet
2018-10-20 12:48:12 +01:00
parent dfa47a6f47
commit 1d16b6cb70
10 changed files with 149 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/loot/api.h
+6 -5
View File
@@ -25,6 +25,7 @@
#ifndef LOOT_API_H
#define LOOT_API_H
#include <filesystem>
#include <functional>
#include <memory>
#include <string>
@@ -116,16 +117,16 @@ LOOT_API void InitialiseLocale(const std::string& id = "");
* game's executable.
* @param game_local_path
* The relative or absolute path to the game's folder in
* `%%LOCALAPPDATA%` or an empty string. If an empty string, the API
* will attempt to look up the path that `%%LOCALAPPDATA%` corresponds to. This
* parameter is provided so that systems lacking that environmental
* `%%LOCALAPPDATA%` or an empty path. If an empty path, the API will
* attempt to look up the path that `%%LOCALAPPDATA%` corresponds to.
* This parameter is provided so that systems lacking that environmental
* variable (eg. Linux) can still use the API.
* @returns The new game handle.
*/
LOOT_API std::shared_ptr<GameInterface> CreateGameHandle(
const GameType game,
const std::string& game_path,
const std::string& game_local_path = "");
const std::filesystem::path& game_path,
const std::filesystem::path& game_local_path = "");
}
#endif
include/loot/database_interface.h
+24 -23
View File
@@ -24,6 +24,7 @@
#ifndef LOOT_DATABASE_INTERFACE
#define LOOT_DATABASE_INTERFACE
#include <filesystem>
#include <optional>
#include <string>
#include <vector>
@@ -48,15 +49,15 @@ public:
* @details Can be called multiple times, each time replacing the
* previously-loaded data.
* @param masterlist_path
* A string containing the relative or absolute path to the masterlist
* file that should be loaded.
* The relative or absolute path to the masterlist file that should be
* loaded.
* @param userlist_path
* A string containing the relative or absolute path to the userlist
* file that should be loaded, or an empty string. If an empty string,
* no userlist will be loaded.
* The relative or absolute path to the userlist file that should be
* loaded, or an empty path. If an empty path, no userlist will be
* loaded.
*/
virtual void LoadLists(const std::string& masterlist_path,
const std::string& userlist_path = "") = 0;
virtual void LoadLists(const std::filesystem::path& masterlist_path,
const std::filesystem::path& userlist_path = "") = 0;
/**
* Writes a metadata file containing all loaded user-added metadata.
@@ -66,7 +67,7 @@ public:
* If `false` and `outputFile` already exists, no data will be
* written. Otherwise, data will be written.
*/
virtual void WriteUserMetadata(const std::string& outputFile,
virtual void WriteUserMetadata(const std::filesystem::path& outputFile,
const bool overwrite) const = 0;
/**
@@ -79,7 +80,7 @@ public:
* If `false` and `outputFile` already exists, no data will be
* written. Otherwise, data will be written.
*/
virtual void WriteMinimalList(const std::string& outputFile,
virtual void WriteMinimalList(const std::filesystem::path& outputFile,
const bool overwrite) const = 0;
/**
@@ -102,12 +103,12 @@ public:
* repository will be deleted and a new repository cloned from
* the given remote.
* @param masterlist_path
* A string containing the relative or absolute path to the masterlist
* file that should be updated. The filename must match the filename
* of the masterlist file in the given remote repository, otherwise it
* will not be updated correctly. Although LOOT itself expects this
* filename to be "masterlist.yaml", the API does not check for any
* specific filename.
* The relative or absolute path to the masterlist file that should be
* updated. The filename must match the filename of the masterlist
* file in the given remote repository, otherwise it will not be
* updated correctly. Although LOOT itself expects this filename to be
* "masterlist.yaml", the API does not check for any specific
* filename.
* @param remote_url
* The URL of the remote from which to fetch updates. This can also be
* a relative or absolute path to a local repository.
@@ -121,7 +122,7 @@ public:
* masterlist will have been re-loaded, but will need to be
* re-evaluated separately.
*/
virtual bool UpdateMasterlist(const std::string& masterlist_path,
virtual bool UpdateMasterlist(const std::filesystem::path& masterlist_path,
const std::string& remote_url,
const std::string& remote_branch) = 0;
@@ -130,8 +131,8 @@ public:
* @details Getting a masterlist's revision is only possible if it is found
* inside a local Git repository.
* @param masterlist_path
* A string containing the relative or absolute path to the masterlist
* file that should be queried.
* The relative or absolute path to the masterlist file that should be
* queried.
* @param get_short_id
* If `true`, the shortest unique hexadecimal revision hash that is at
* least 7 characters long will be outputted. Otherwise, the full 40
@@ -139,21 +140,21 @@ public:
* @returns The revision data.
*/
virtual MasterlistInfo GetMasterlistRevision(
const std::string& masterlist_path,
const std::filesystem::path& masterlist_path,
const bool get_short_id) const = 0;
/**
* Check if the given masterlist is the latest available for a given branch.
* @param masterlist_path
* A string containing the relative or absolute path to the masterlist
* file for which the latest revision should be obtained. It needs to
* be in a local Git repository.
* The relative or absolute path to the masterlist file for which the
* latest revision should be obtained. It needs to be in a local Git
* repository.
* @param branch
* The branch to check against.
* @return True if the masterlist revision matches the latest masterlist
* revision for the given branch, and false otherwise.
*/
virtual bool IsLatestMasterlist(const std::string& masterlist_path,
virtual bool IsLatestMasterlist(const std::filesystem::path& masterlist_path,
const std::string& branch) const = 0;
/**
src/api/api.cpp
+10 -10
View File
@@ -34,9 +34,9 @@
namespace fs = std::filesystem;
namespace loot {
std::string ResolvePath(const std::string& path) {
std::filesystem::path ResolvePath(const std::filesystem::path& path) {
if (fs::is_symlink(path))
return fs::read_symlink(path).string();
return fs::read_symlink(path);
return path;
}
@@ -66,25 +66,25 @@ LOOT_API void InitialiseLocale(const std::string& id) {
LOOT_API std::shared_ptr<GameInterface> CreateGameHandle(
const GameType game,
const std::string& gamePath,
const std::string& gameLocalPath) {
const std::filesystem::path& gamePath,
const std::filesystem::path& gameLocalPath) {
auto logger = getLogger();
if (logger) {
logger->info(
"Attempting to create a game handle with game path \"{}\" "
"and local path \"{}\"",
gamePath,
gameLocalPath);
gamePath.string(),
gameLocalPath.string());
}
const std::string resolvedGamePath = ResolvePath(gamePath);
auto resolvedGamePath = ResolvePath(gamePath);
if (!fs::is_directory(resolvedGamePath))
throw std::invalid_argument("Given game path \"" + gamePath +
throw std::invalid_argument("Given game path \"" + gamePath.string() +
"\" does not resolve to a valid directory.");
const std::string resolvedGameLocalPath = ResolvePath(gameLocalPath);
auto resolvedGameLocalPath = ResolvePath(gameLocalPath);
if (!gameLocalPath.empty() && !fs::is_directory(resolvedGameLocalPath))
throw std::invalid_argument("Given game path \"" + gameLocalPath +
throw std::invalid_argument("Given game local path \"" + gameLocalPath.string() +
"\" does not resolve to a valid directory.");
return std::make_shared<Game>(game, resolvedGamePath, resolvedGameLocalPath);
src/api/api_database.cpp
+14 -16
View File
@@ -46,8 +46,8 @@ ApiDatabase::ApiDatabase(const GameType gameType,
// Database Loading Functions
///////////////////////////////////
void ApiDatabase::LoadLists(const std::string& masterlistPath,
const std::string& userlistPath) {
void ApiDatabase::LoadLists(const std::filesystem::path& masterlistPath,
const std::filesystem::path& userlistPath) {
Masterlist temp;
MetadataList userTemp;
@@ -56,7 +56,7 @@ void ApiDatabase::LoadLists(const std::string& masterlistPath,
temp.Load(masterlistPath);
} else {
throw FileAccessError("The given masterlist path does not exist: " +
masterlistPath);
masterlistPath.string());
}
}
@@ -65,7 +65,7 @@ void ApiDatabase::LoadLists(const std::string& masterlistPath,
userTemp.Load(userlistPath);
} else {
throw FileAccessError("The given userlist path does not exist: " +
userlistPath);
userlistPath.string());
}
}
@@ -73,10 +73,9 @@ void ApiDatabase::LoadLists(const std::string& masterlistPath,
userlist_ = userTemp;
}
void ApiDatabase::WriteUserMetadata(const std::string& outputFile,
void ApiDatabase::WriteUserMetadata(const std::filesystem::path& outputFile,
const bool overwrite) const {
if (!std::filesystem::exists(
std::filesystem::path(outputFile).parent_path()))
if (!std::filesystem::exists(outputFile.parent_path()))
throw std::invalid_argument("Output directory does not exist.");
if (std::filesystem::exists(outputFile) && !overwrite)
@@ -90,12 +89,11 @@ void ApiDatabase::WriteUserMetadata(const std::string& outputFile,
// LOOT Functionality Functions
////////////////////////////////////
bool ApiDatabase::UpdateMasterlist(const std::string& masterlistPath,
bool ApiDatabase::UpdateMasterlist(const std::filesystem::path& masterlistPath,
const std::string& remoteURL,
const std::string& remoteBranch) {
if (!std::filesystem::is_directory(
std::filesystem::path(masterlistPath).parent_path()))
throw std::invalid_argument("Given masterlist path \"" + masterlistPath +
if (!std::filesystem::is_directory(masterlistPath.parent_path()))
throw std::invalid_argument("Given masterlist path \"" + masterlistPath.string() +
"\" does not have a valid parent directory.");
Masterlist masterlist;
@@ -108,12 +106,13 @@ bool ApiDatabase::UpdateMasterlist(const std::string& masterlistPath,
}
MasterlistInfo ApiDatabase::GetMasterlistRevision(
const std::string& masterlistPath,
const std::filesystem::path& masterlistPath,
const bool getShortID) const {
return Masterlist::GetInfo(masterlistPath, getShortID);
}
bool ApiDatabase::IsLatestMasterlist(const std::string& masterlist_path,
bool ApiDatabase::IsLatestMasterlist(
const std::filesystem::path& masterlist_path,
const std::string& branch) const {
return Masterlist::IsLatest(masterlist_path, branch);
}
@@ -248,10 +247,9 @@ void ApiDatabase::DiscardAllUserMetadata() { userlist_.Clear(); }
// themselves and their conditions, in order to create the Wrye Bash taglist.
// outputFile is the path to use for output. If outputFile already exists, it
// will only be overwritten if overwrite is true.
void ApiDatabase::WriteMinimalList(const std::string& outputFile,
void ApiDatabase::WriteMinimalList(const std::filesystem::path& outputFile,
const bool overwrite) const {
if (!std::filesystem::exists(
std::filesystem::path(outputFile).parent_path()))
if (!std::filesystem::exists(outputFile.parent_path()))
throw std::invalid_argument("Output directory does not exist.");
if (std::filesystem::exists(outputFile) && !overwrite)
src/api/api_database.h
+9 -8
View File
@@ -44,23 +44,24 @@ struct ApiDatabase : public DatabaseInterface {
std::shared_ptr<GameCache> gameCache,
std::shared_ptr<LoadOrderHandler> loadOrderHandler);
void LoadLists(const std::string& masterlist_path,
const std::string& userlist_path = "");
void LoadLists(const std::filesystem::path& masterlist_path,
const std::filesystem::path& userlist_path = "");
void WriteUserMetadata(const std::string& outputFile,
void WriteUserMetadata(const std::filesystem::path& outputFile,
const bool overwrite) const;
void WriteMinimalList(const std::string& outputFile,
void WriteMinimalList(const std::filesystem::path& outputFile,
const bool overwrite) const;
bool UpdateMasterlist(const std::string& masterlist_path,
bool UpdateMasterlist(const std::filesystem::path& masterlist_path,
const std::string& remote_url,
const std::string& remote_branch);
MasterlistInfo GetMasterlistRevision(const std::string& masterlist_path,
const bool get_short_id) const;
MasterlistInfo GetMasterlistRevision(
const std::filesystem::path& masterlist_path,
const bool get_short_id) const;
bool IsLatestMasterlist(const std::string& masterlist_path,
bool IsLatestMasterlist(const std::filesystem::path& masterlist_path,
const std::string& branch) const;
std::set<std::string> GetKnownBashTags() const;
src/tests/api/interface/api_game_operations_test.h
+1 -1
View File
@@ -53,7 +53,7 @@ protected:
ASSERT_FALSE(std::filesystem::exists(masterlistPath));
handle_ = CreateGameHandle(
GetParam(), dataPath.parent_path().string(), localPath.string());
GetParam(), dataPath.parent_path(), localPath);
}
void GenerateMasterlist() {
src/tests/api/interface/create_game_handle_test.h
+11 -11
View File
@@ -90,44 +90,44 @@ TEST_P(CreateGameHandleTest,
shouldSucceedIfPassedValidParametersWithRelativePaths) {
using std::filesystem::relative;
EXPECT_NO_THROW(handle_ = CreateGameHandle(GetParam(),
relative(dataPath.parent_path()).string(),
relative(localPath).string()));
relative(dataPath.parent_path()),
relative(localPath)));
EXPECT_TRUE(handle_);
}
TEST_P(CreateGameHandleTest,
shouldSucceedIfPassedValidParametersWithAbsolutePaths) {
EXPECT_NO_THROW(handle_ = CreateGameHandle(GetParam(),
dataPath.parent_path().string(),
localPath.string()));
dataPath.parent_path(),
localPath));
EXPECT_TRUE(handle_);
}
TEST_P(CreateGameHandleTest, shouldThrowIfPassedAGamePathThatDoesNotExist) {
EXPECT_THROW(
CreateGameHandle(GetParam(), missingPath.string(), localPath.string()),
CreateGameHandle(GetParam(), missingPath, localPath),
std::invalid_argument);
}
TEST_P(CreateGameHandleTest, shouldThrowIfPassedALocalPathThatDoesNotExist) {
EXPECT_THROW(
CreateGameHandle(
GetParam(), dataPath.parent_path().string(), missingPath.string()),
GetParam(), dataPath.parent_path(), missingPath),
std::invalid_argument);
}
#ifdef _WIN32
TEST_P(CreateGameHandleTest, shouldReturnOkIfPassedAnEmptyLocalPathString) {
EXPECT_NO_THROW(handle_ = CreateGameHandle(
GetParam(), dataPath.parent_path().string(), ""));
GetParam(), dataPath.parent_path(), ""));
EXPECT_TRUE(handle_);
}
#endif
TEST_P(CreateGameHandleTest, shouldReturnOkIfPassedGameAndLocalPathSymlinks) {
EXPECT_NO_THROW(handle_ = CreateGameHandle(GetParam(),
gamePathSymlink.string(),
localPathSymlink.string()));
gamePathSymlink,
localPathSymlink));
EXPECT_TRUE(handle_);
}
@@ -135,8 +135,8 @@ TEST_P(CreateGameHandleTest, shouldReturnOkIfPassedGameAndLocalPathSymlinks) {
TEST_P(CreateGameHandleTest,
shouldReturnOkIfPassedGameAndLocalPathJunctionLinks) {
EXPECT_NO_THROW(handle_ = CreateGameHandle(GetParam(),
gamePathJunctionLink.string(),
localPathJunctionLink.string()));
gamePathJunctionLink,
localPathJunctionLink));
EXPECT_TRUE(handle_);
}
#endif
src/tests/api/interface/database_interface_test.h
+67 -67
View File
@@ -132,23 +132,23 @@ INSTANTIATE_TEST_CASE_P(,
TEST_P(DatabaseInterfaceTest,
loadListsShouldSucceedEvenIfGameHandleIsDiscarded) {
db_ = CreateGameHandle(
GetParam(), dataPath.parent_path().string(), localPath.string())
GetParam(), dataPath.parent_path(), localPath)
->GetDatabase();
ASSERT_NO_THROW(GenerateMasterlist());
EXPECT_NO_THROW(db_->LoadLists(masterlistPath.string(), ""));
EXPECT_NO_THROW(db_->LoadLists(masterlistPath, ""));
}
TEST_P(DatabaseInterfaceTest, loadListsShouldThrowIfNoMasterlistIsPresent) {
EXPECT_THROW(db_->LoadLists(masterlistPath.string(), ""), FileAccessError);
EXPECT_THROW(db_->LoadLists(masterlistPath, ""), FileAccessError);
}
TEST_P(
DatabaseInterfaceTest,
loadListsShouldThrowIfAMasterlistIsPresentButAUserlistDoesNotExistAtTheGivenPath) {
ASSERT_NO_THROW(GenerateMasterlist());
EXPECT_THROW(db_->LoadLists(masterlistPath.string(), userlistPath_.string()),
EXPECT_THROW(db_->LoadLists(masterlistPath, userlistPath_),
FileAccessError);
}
@@ -157,7 +157,7 @@ TEST_P(
loadListsShouldSucceedIfTheMasterlistIsPresentAndTheUserlistPathIsAnEmptyString) {
ASSERT_NO_THROW(GenerateMasterlist());
EXPECT_NO_THROW(db_->LoadLists(masterlistPath.string(), ""));
EXPECT_NO_THROW(db_->LoadLists(masterlistPath, ""));
}
TEST_P(DatabaseInterfaceTest,
@@ -166,54 +166,54 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(std::filesystem::copy(masterlistPath, userlistPath_));
EXPECT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
}
TEST_P(
DatabaseInterfaceTest,
writeUserMetadataShouldThrowIfTheFileAlreadyExistsAndTheOverwriteArgumentIsFalse) {
ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), false));
ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, false));
ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
EXPECT_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), false),
EXPECT_THROW(db_->WriteUserMetadata(minimalOutputPath_, false),
FileAccessError);
}
TEST_P(
DatabaseInterfaceTest,
writeUserMetadataShouldReturnOkAndWriteToFileIfTheArgumentsAreValidAndTheOverwriteArgumentIsTrue) {
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), true));
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
EXPECT_TRUE(std::filesystem::exists(minimalOutputPath_));
}
TEST_P(
DatabaseInterfaceTest,
writeUserMetadataShouldReturnOkIfTheFileAlreadyExistsAndTheOverwriteArgumentIsTrue) {
ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), false));
ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, false));
ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), true));
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
}
TEST_P(DatabaseInterfaceTest,
writeUserMetadataShouldThrowIfPathGivenExistsAndIsReadOnly) {
ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), false));
ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, false));
ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
std::filesystem::permissions(minimalOutputPath_,
std::filesystem::perms::owner_read,
std::filesystem::perm_options::replace);
EXPECT_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), true),
EXPECT_THROW(db_->WriteUserMetadata(minimalOutputPath_, true),
FileAccessError);
}
TEST_P(DatabaseInterfaceTest,
writeUserMetadataShouldShouldNotWriteMasterlistMetadata) {
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(db_->LoadLists(masterlistPath.string(), ""));
ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), true));
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
EXPECT_EQ("{}", GetFileContent(minimalOutputPath_));
}
@@ -227,9 +227,9 @@ TEST_P(DatabaseInterfaceTest, writeUserMetadataShouldShouldWriteUserMetadata) {
masterlist.close();
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_.string(), true));
EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
EXPECT_FALSE(GetFileContent(minimalOutputPath_).empty());
}
@@ -248,7 +248,7 @@ TEST_P(DatabaseInterfaceTest,
TEST_P(DatabaseInterfaceTest,
updateMasterlistShouldThrowIfTheRepositoryUrlGivenCannotBeFound) {
EXPECT_THROW(db_->UpdateMasterlist(
masterlistPath.string(),
masterlistPath,
"https://github.com/loot/oblivion-does-not-exist.git",
branch_),
std::system_error);
@@ -256,20 +256,20 @@ TEST_P(DatabaseInterfaceTest,
TEST_P(DatabaseInterfaceTest,
updateMasterlistShouldThrowIfTheRepositoryUrlGivenIsEmpty) {
EXPECT_THROW(db_->UpdateMasterlist(masterlistPath.string(), "", branch_),
EXPECT_THROW(db_->UpdateMasterlist(masterlistPath, "", branch_),
std::invalid_argument);
}
TEST_P(DatabaseInterfaceTest,
updateMasterlistShouldThrowIfTheRepositoryBranchGivenCannotBeFound) {
EXPECT_THROW(
db_->UpdateMasterlist(masterlistPath.string(), url_, "missing-branch"),
db_->UpdateMasterlist(masterlistPath, url_, "missing-branch"),
std::system_error);
}
TEST_P(DatabaseInterfaceTest,
updateMasterlistShouldThrowIfTheRepositoryBranchGivenIsEmpty) {
EXPECT_THROW(db_->UpdateMasterlist(masterlistPath.string(), url_, ""),
EXPECT_THROW(db_->UpdateMasterlist(masterlistPath, url_, ""),
std::invalid_argument);
}
@@ -278,7 +278,7 @@ TEST_P(
updateMasterlistShouldSucceedIfPassedValidParametersAndOutputTrueIfTheMasterlistWasUpdated) {
bool updated = false;
EXPECT_NO_THROW(
updated = db_->UpdateMasterlist(masterlistPath.string(), url_, branch_));
updated = db_->UpdateMasterlist(masterlistPath, url_, branch_));
EXPECT_TRUE(updated);
EXPECT_TRUE(std::filesystem::exists(masterlistPath));
}
@@ -288,11 +288,11 @@ TEST_P(
updateMasterlistShouldSucceedIfCalledRepeatedlyButOnlyOutputTrueForTheFirstCall) {
bool updated = false;
EXPECT_NO_THROW(
updated = db_->UpdateMasterlist(masterlistPath.string(), url_, branch_));
updated = db_->UpdateMasterlist(masterlistPath, url_, branch_));
EXPECT_TRUE(updated);
EXPECT_NO_THROW(
updated = db_->UpdateMasterlist(masterlistPath.string(), url_, branch_));
updated = db_->UpdateMasterlist(masterlistPath, url_, branch_));
EXPECT_FALSE(updated);
EXPECT_TRUE(std::filesystem::exists(masterlistPath));
}
@@ -301,7 +301,7 @@ TEST_P(DatabaseInterfaceTest,
getMasterlistRevisionShouldThrowIfNoMasterlistIsPresent) {
MasterlistInfo info;
EXPECT_THROW(
info = db_->GetMasterlistRevision(masterlistPath.string(), false),
info = db_->GetMasterlistRevision(masterlistPath, false),
FileAccessError);
EXPECT_TRUE(info.revision_id.empty());
EXPECT_TRUE(info.revision_date.empty());
@@ -315,7 +315,7 @@ TEST_P(
MasterlistInfo info;
EXPECT_THROW(
info = db_->GetMasterlistRevision(masterlistPath.string(), false),
info = db_->GetMasterlistRevision(masterlistPath, false),
GitStateError);
EXPECT_TRUE(info.revision_id.empty());
EXPECT_TRUE(info.revision_date.empty());
@@ -326,11 +326,11 @@ TEST_P(
DatabaseInterfaceTest,
getMasterlistRevisionShouldOutputLongStringsAndBooleanFalseIfAVersionControlledMasterlistIsPresentAndGetShortIdParameterIsFalse) {
ASSERT_NO_THROW(
db_->UpdateMasterlist(masterlistPath.string(), url_, branch_));
db_->UpdateMasterlist(masterlistPath, url_, branch_));
MasterlistInfo info;
EXPECT_NO_THROW(
info = db_->GetMasterlistRevision(masterlistPath.string(), false));
info = db_->GetMasterlistRevision(masterlistPath, false));
EXPECT_EQ(40, info.revision_id.length());
EXPECT_EQ(10, info.revision_date.length());
EXPECT_FALSE(info.is_modified);
@@ -340,11 +340,11 @@ TEST_P(
DatabaseInterfaceTest,
getMasterlistRevisionShouldOutputShortStringsAndBooleanFalseIfAVersionControlledMasterlistIsPresentAndGetShortIdParameterIsTrue) {
ASSERT_NO_THROW(
db_->UpdateMasterlist(masterlistPath.string(), url_, branch_));
db_->UpdateMasterlist(masterlistPath, url_, branch_));
MasterlistInfo info;
EXPECT_NO_THROW(
info = db_->GetMasterlistRevision(masterlistPath.string(), false));
info = db_->GetMasterlistRevision(masterlistPath, false));
EXPECT_GE(size_t(40), info.revision_id.length());
EXPECT_LE(size_t(7), info.revision_id.length());
EXPECT_EQ(10, info.revision_date.length());
@@ -355,12 +355,12 @@ TEST_P(
DatabaseInterfaceTest,
getMasterlistRevisionShouldSucceedIfAnEditedVersionControlledMasterlistIsPresent) {
ASSERT_NO_THROW(
db_->UpdateMasterlist(masterlistPath.string(), url_, branch_));
db_->UpdateMasterlist(masterlistPath, url_, branch_));
ASSERT_NO_THROW(GenerateMasterlist());
MasterlistInfo info;
EXPECT_NO_THROW(
info = db_->GetMasterlistRevision(masterlistPath.string(), false));
info = db_->GetMasterlistRevision(masterlistPath, false));
EXPECT_EQ(40, info.revision_id.length());
EXPECT_EQ(10, info.revision_date.length());
EXPECT_TRUE(info.is_modified);
@@ -370,18 +370,18 @@ TEST_P(
DatabaseInterfaceTest,
isLatestMasterlistShouldReturnFalseIfTheCurrentRevisionIsNotTheLatestRevisionInTheGivenBranch) {
ASSERT_NO_THROW(
db_->UpdateMasterlist(masterlistPath.string(), url_, oldBranch_));
db_->UpdateMasterlist(masterlistPath, url_, oldBranch_));
EXPECT_FALSE(db_->IsLatestMasterlist(masterlistPath.string(), branch_));
EXPECT_FALSE(db_->IsLatestMasterlist(masterlistPath, branch_));
}
TEST_P(
DatabaseInterfaceTest,
isLatestMasterlistShouldReturnTrueIfTheCurrentRevisionIsTheLatestRevisioninTheGivenBranch) {
ASSERT_NO_THROW(
db_->UpdateMasterlist(masterlistPath.string(), url_, branch_));
db_->UpdateMasterlist(masterlistPath, url_, branch_));
EXPECT_TRUE(db_->IsLatestMasterlist(masterlistPath.string(), branch_));
EXPECT_TRUE(db_->IsLatestMasterlist(masterlistPath, branch_));
}
TEST_P(DatabaseInterfaceTest,
@@ -390,7 +390,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto groups = db_->GetGroups();
@@ -425,7 +425,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto groups = db_->GetGroups(false);
@@ -457,7 +457,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto groups = db_->GetUserGroups();
@@ -479,7 +479,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
db_->SetUserGroups(std::unordered_set<Group>({
Group("group4"),
@@ -502,7 +502,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto tags = db_->GetKnownBashTags();
@@ -520,7 +520,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto messages = db_->GetGeneralMessages();
@@ -535,7 +535,7 @@ TEST_P(
DatabaseInterfaceTest,
getGeneralMessagesShouldReturnOnlyValidMessagesIfConditionsAreEvaluated) {
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(db_->LoadLists(masterlistPath.string(), ""));
ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
auto messages = db_->GetGeneralMessages(true);
@@ -554,7 +554,7 @@ TEST_P(
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto metadata = db_->GetPluginMetadata(blankEsm, true).value();
@@ -571,7 +571,7 @@ TEST_P(
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto metadata = db_->GetPluginMetadata(blankEsm, false).value();
@@ -585,7 +585,7 @@ TEST_P(
DatabaseInterfaceTest,
getPluginMetadataShouldReturnOnlyValidMetadataForTheGivenPluginIfConditionsAreEvaluated) {
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(db_->LoadLists(masterlistPath.string(), ""));
ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
auto metadata = db_->GetPluginMetadata(blankEsm, false, true).value();
@@ -598,7 +598,7 @@ TEST_P(
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
EXPECT_FALSE(db_->GetPluginUserMetadata(blankDifferentEsm));
}
@@ -608,7 +608,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto metadata = db_->GetPluginUserMetadata(blankEsm).value();
@@ -624,7 +624,7 @@ TEST_P(
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
auto metadata = db_->GetPluginMetadata(blankEsm, false, true).value();
@@ -637,7 +637,7 @@ TEST_P(
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
PluginMetadata newMetadata(blankDifferentEsp);
newMetadata.SetRequirements(std::set<File>({File(masterFile)}));
@@ -658,7 +658,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
PluginMetadata newMetadata(blankEsm);
newMetadata.SetRequirements(std::set<File>({File(masterFile)}));
@@ -678,7 +678,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
db_->DiscardPluginUserMetadata(blankEsm);
@@ -691,7 +691,7 @@ TEST_P(
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
db_->DiscardPluginUserMetadata(blankEsm);
@@ -708,7 +708,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
db_->DiscardPluginUserMetadata(blankEsm);
@@ -722,7 +722,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
db_->DiscardPluginUserMetadata(blankEsm);
@@ -740,7 +740,7 @@ TEST_P(DatabaseInterfaceTest,
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
db_->DiscardPluginUserMetadata(blankEsm);
@@ -761,7 +761,7 @@ TEST_P(
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(GenerateUserlist());
ASSERT_NO_THROW(
db_->LoadLists(masterlistPath.string(), userlistPath_.string()));
db_->LoadLists(masterlistPath, userlistPath_));
db_->DiscardAllUserMetadata();
@@ -793,55 +793,55 @@ TEST_P(
TEST_P(DatabaseInterfaceTest,
writeMinimalListShouldReturnOkAndWriteToFileIfArgumentsGivenAreValid) {
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), false));
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
EXPECT_TRUE(std::filesystem::exists(minimalOutputPath_));
}
TEST_P(
DatabaseInterfaceTest,
writeMinimalListShouldThrowIfTheFileAlreadyExistsAndTheOverwriteArgumentIsFalse) {
ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), false));
ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
EXPECT_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), false),
EXPECT_THROW(db_->WriteMinimalList(minimalOutputPath_, false),
FileAccessError);
}
TEST_P(
DatabaseInterfaceTest,
writeMinimalListShouldReturnOkAndWriteToFileIfTheArgumentsAreValidAndTheOverwriteArgumentIsTrue) {
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), true));
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, true));
EXPECT_TRUE(std::filesystem::exists(minimalOutputPath_));
}
TEST_P(
DatabaseInterfaceTest,
writeMinimalListShouldReturnOkIfTheFileAlreadyExistsAndTheOverwriteArgumentIsTrue) {
ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), false));
ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), true));
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, true));
}
TEST_P(DatabaseInterfaceTest,
writeMinimalListShouldThrowIfPathGivenExistsAndIsReadOnly) {
ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), false));
ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
std::filesystem::permissions(minimalOutputPath_,
std::filesystem::perms::owner_read,
std::filesystem::perm_options::replace);
EXPECT_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), true),
EXPECT_THROW(db_->WriteMinimalList(minimalOutputPath_, true),
FileAccessError);
}
TEST_P(DatabaseInterfaceTest,
writeMinimalListShouldWriteOnlyBashTagsAndDirtyInfo) {
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(db_->LoadLists(masterlistPath.string(), ""));
ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_.string(), true));
EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, true));
EXPECT_EQ(GetExpectedMinimalContent(), GetFileContent(minimalOutputPath_));
}
src/tests/api/interface/game_interface_test.h
+1 -1
View File
@@ -140,7 +140,7 @@ TEST_P(GameInterfaceTest, sortPluginsShouldSucceedIfPassedValidArguments) {
ASSERT_NO_THROW(GenerateMasterlist());
ASSERT_NO_THROW(
handle_->GetDatabase()->LoadLists(masterlistPath.string(), ""));
handle_->GetDatabase()->LoadLists(masterlistPath, ""));
std::vector<std::string> pluginsToSort({
blankEsp,
src/tests/api/internals/sorting/plugin_sorter_test.h
+6 -6
View File
@@ -189,7 +189,7 @@ TEST_P(PluginSorterTest, sortingShouldResolveGroupsAsTransitiveLoadAfterSets) {
ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
GenerateMasterlist();
game_.GetDatabase()->LoadLists(masterlistPath_.string());
game_.GetDatabase()->LoadLists(masterlistPath_);
PluginMetadata plugin(blankDifferentEsm);
plugin.SetGroup("group1");
@@ -238,7 +238,7 @@ TEST_P(PluginSorterTest,
ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
GenerateMasterlist();
game_.GetDatabase()->LoadLists(masterlistPath_.string());
game_.GetDatabase()->LoadLists(masterlistPath_);
PluginMetadata plugin(blankEsm);
plugin.SetGroup("group4");
@@ -273,7 +273,7 @@ TEST_P(
ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
GenerateMasterlist();
game_.GetDatabase()->LoadLists(masterlistPath_.string());
game_.GetDatabase()->LoadLists(masterlistPath_);
PluginMetadata plugin(blankEsp);
@@ -318,7 +318,7 @@ TEST_P(
ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
GenerateMasterlist();
game_.GetDatabase()->LoadLists(masterlistPath_.string());
game_.GetDatabase()->LoadLists(masterlistPath_);
PluginMetadata plugin(blankMasterDependentEsm);
plugin.SetGroup("earliest");
@@ -359,7 +359,7 @@ TEST_P(
ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
GenerateMasterlist();
game_.GetDatabase()->LoadLists(masterlistPath_.string());
game_.GetDatabase()->LoadLists(masterlistPath_);
PluginMetadata plugin(blankMasterDependentEsm);
plugin.SetGroup("earliest");
@@ -383,7 +383,7 @@ TEST_P(
ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
GenerateMasterlist();
game_.GetDatabase()->LoadLists(masterlistPath_.string());
game_.GetDatabase()->LoadLists(masterlistPath_);
PluginMetadata plugin(blankEsm);
plugin.SetGroup("group4");