Migrated scrobbling stuff
This commit is contained in:
emeric
@@ -1,368 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2021 Emeric Poupon
|
||||
*
|
||||
* This file is part of LMS.
|
||||
*
|
||||
* LMS 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.
|
||||
*
|
||||
* LMS 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 LMS. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "Common.hpp"
|
||||
|
||||
using namespace Database;
|
||||
|
||||
TEST_F(DatabaseFixture, SingleArtist)
|
||||
{
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_FALSE(Artist::exists(session, 35));
|
||||
EXPECT_FALSE(Artist::exists(session, 0));
|
||||
EXPECT_FALSE(Artist::exists(session, 1));
|
||||
}
|
||||
|
||||
ScopedArtist artist {session, "MyArtist"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_TRUE(artist.get());
|
||||
EXPECT_FALSE(!artist.get());
|
||||
EXPECT_EQ(artist.get()->getId(), artist.getId());
|
||||
|
||||
EXPECT_TRUE(Artist::exists(session, artist.getId()));
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto artists {Artist::getAll(session, Artist::SortMethod::ByName)};
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist.getId());
|
||||
|
||||
artists = Artist::getAllOrphans(session);
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackSingleArtist)
|
||||
{
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
ScopedArtist artist {session, "MyArtist"};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto artists {track->getArtists({TrackArtistLinkType::Artist})};
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist.getId());
|
||||
|
||||
EXPECT_EQ(artist->getReleaseCount(), 0);
|
||||
|
||||
ASSERT_EQ(track->getArtistLinks().size(), 1);
|
||||
auto artistLink {track->getArtistLinks().front()};
|
||||
EXPECT_EQ(artistLink->getTrack()->getId(), track.getId());
|
||||
EXPECT_EQ(artistLink->getArtist()->getId(), artist.getId());
|
||||
|
||||
ASSERT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 1);
|
||||
EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
|
||||
EXPECT_EQ(track->getArtists({}).size(), 1);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
auto tracks {artist->getTracks()};
|
||||
ASSERT_EQ(tracks.size(), 1);
|
||||
EXPECT_EQ(tracks.front()->getId(), track.getId());
|
||||
|
||||
EXPECT_TRUE(artist->getTracks(TrackArtistLinkType::ReleaseArtist).empty());
|
||||
EXPECT_EQ(artist->getTracks(TrackArtistLinkType::Artist).size(), 1);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRoles)
|
||||
{
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
ScopedArtist artist {session, "MyArtist"};
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::ReleaseArtist);
|
||||
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Writer);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
bool hasMore{};
|
||||
EXPECT_EQ(Artist::getByFilter(session, {}, {}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
|
||||
EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Artist, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
|
||||
EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::ReleaseArtist, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
|
||||
EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Writer, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
|
||||
EXPECT_TRUE(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Composer, Artist::SortMethod::ByName, std::nullopt, hasMore).empty());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto artists {track->getArtists({TrackArtistLinkType::Artist})};
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist.getId());
|
||||
|
||||
artists = track->getArtists({TrackArtistLinkType::ReleaseArtist});
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist.getId());
|
||||
|
||||
EXPECT_EQ(track->getArtistLinks().size(), 3);
|
||||
|
||||
EXPECT_EQ(artist->getTracks().size(), 1);
|
||||
EXPECT_EQ(artist->getTracks({TrackArtistLinkType::ReleaseArtist}).size(), 1);
|
||||
EXPECT_EQ(artist->getTracks({TrackArtistLinkType::Artist}).size(), 1);
|
||||
EXPECT_EQ(artist->getTracks({TrackArtistLinkType::Writer}).size(), 1);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture,SingleTrackMultiArtists)
|
||||
{
|
||||
ScopedTrack track {session, "track"};
|
||||
ScopedArtist artist1 {session, "artist1"};
|
||||
ScopedArtist artist2 {session, "artist2"};
|
||||
ASSERT_NE(artist1.getId(), artist2.getId());
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackArtistLink::create(session, track.get(), artist1.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track.get(), artist2.get(), TrackArtistLinkType::Artist);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto artists {track->getArtists({TrackArtistLinkType::Artist})};
|
||||
ASSERT_EQ(artists.size(), 2);
|
||||
EXPECT_TRUE((artists[0]->getId() == artist1.getId() && artists[1]->getId() == artist2.getId())
|
||||
|| (artists[0]->getId() == artist2.getId() && artists[1]->getId() == artist1.getId()));
|
||||
|
||||
EXPECT_EQ(track->getArtists({}).size(), 2);
|
||||
EXPECT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 2);
|
||||
EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
|
||||
EXPECT_EQ(Artist::getAll(session, Artist::SortMethod::ByName).size(), 2);
|
||||
EXPECT_EQ(Artist::getAllIds(session).size(), 2);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
EXPECT_EQ(artist1->getTracks().front(), track.get());
|
||||
EXPECT_EQ(artist2->getTracks().front(), track.get());
|
||||
|
||||
EXPECT_TRUE(artist1->getTracks(TrackArtistLinkType::ReleaseArtist).empty());
|
||||
EXPECT_EQ(artist1->getTracks(TrackArtistLinkType::Artist).size(), 1);
|
||||
EXPECT_TRUE(artist2->getTracks(TrackArtistLinkType::ReleaseArtist).empty());
|
||||
EXPECT_EQ(artist2->getTracks(TrackArtistLinkType::Artist).size(), 1);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleArtistSearchByName)
|
||||
{
|
||||
ScopedArtist artist {session, "AAA"};
|
||||
ScopedTrack track {session, "MyTrack"}; // filters does not work on orphans
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
artist.get().modify()->setSortName("ZZZ");
|
||||
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool more {};
|
||||
EXPECT_TRUE(Artist::getByFilter(session, {}, {"N"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more).empty());
|
||||
|
||||
const auto artistsByAAA {Artist::Artist::getByFilter(session, {}, {"A"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
|
||||
ASSERT_EQ(artistsByAAA.size(), 1);
|
||||
EXPECT_EQ(artistsByAAA.front()->getId(), artist.getId());
|
||||
|
||||
const auto artistsByZZZ {Artist::Artist::getByFilter(session, {}, {"Z"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
|
||||
ASSERT_EQ(artistsByZZZ.size(), 1);
|
||||
EXPECT_EQ(artistsByZZZ.front()->getId(), artist.getId());
|
||||
|
||||
EXPECT_TRUE(Artist::getByName(session, "NNN").empty());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, MultipleArtistsSearchByNameEscaped)
|
||||
{
|
||||
ScopedArtist artist1 {session, "MyArtist%"};
|
||||
ScopedArtist artist2 {session, "%MyArtist"};
|
||||
ScopedArtist artist3 {session, "%_MyArtist"};
|
||||
|
||||
ScopedArtist artist4 {session, "MyArtist%foo"};
|
||||
ScopedArtist artist5 {session, "foo%MyArtist"};
|
||||
ScopedArtist artist6 {session, "%AMyArtist"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
{
|
||||
const auto artists {Artist::getByName(session, "MyArtist%")};
|
||||
ASSERT_TRUE(artists.size() == 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist1.getId());
|
||||
EXPECT_TRUE(Artist::getByName(session, "MyArtistFoo").empty());
|
||||
}
|
||||
{
|
||||
const auto artists {Artist::getByName(session, "%MyArtist")};
|
||||
ASSERT_TRUE(artists.size() == 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist2.getId());
|
||||
EXPECT_TRUE(Artist::getByName(session, "FooMyArtist").empty());
|
||||
}
|
||||
{
|
||||
const auto artists {Artist::getByName(session, "%_MyArtist")};
|
||||
ASSERT_TRUE(artists.size() == 1);
|
||||
ASSERT_EQ(artists.front()->getId(), artist3.getId());
|
||||
EXPECT_TRUE(Artist::getByName(session, "%CMyArtist").empty());
|
||||
}
|
||||
}
|
||||
|
||||
// get by filter only works with tracks links...
|
||||
ScopedTrack track {session, "MyTrack"}; // filters does not work on orphans
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackArtistLink::create(session, track.get(), artist1.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track.get(), artist2.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track.get(), artist3.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track.get(), artist4.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track.get(), artist5.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track.get(), artist6.get(), TrackArtistLinkType::Artist);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
bool more;
|
||||
{
|
||||
const auto artists {Artist::getByFilter(session, {}, {"MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
|
||||
EXPECT_EQ(artists.size(), 6);
|
||||
}
|
||||
|
||||
{
|
||||
const auto artists {Artist::getByFilter(session, {}, {"MyArtist%"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
|
||||
ASSERT_EQ(artists.size(), 2);
|
||||
EXPECT_EQ(artists[0]->getId(), artist1.getId());
|
||||
EXPECT_EQ(artists[1]->getId(), artist4.getId());
|
||||
}
|
||||
|
||||
{
|
||||
const auto artists {Artist::getByFilter(session, {}, {"%MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
|
||||
ASSERT_EQ(artists.size(), 2);
|
||||
EXPECT_EQ(artists[0]->getId(), artist2.getId());
|
||||
EXPECT_EQ(artists[1]->getId(), artist5.getId());
|
||||
}
|
||||
|
||||
{
|
||||
const auto artists {Artist::getByFilter(session, {}, {"_MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists[0]->getId(), artist3.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, MultiArtistsSortMethod)
|
||||
{
|
||||
ScopedArtist artistA {session, "artistA"};
|
||||
ScopedArtist artistB {session, "artistB"};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
artistA.get().modify()->setSortName("sortNameB");
|
||||
artistB.get().modify()->setSortName("sortNameA");
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto allArtistsByName {Artist::getAll(session, Artist::SortMethod::ByName)};
|
||||
auto allArtistsBySortName {Artist::getAll(session, Artist::SortMethod::BySortName)};
|
||||
|
||||
ASSERT_EQ(allArtistsByName.size(), 2);
|
||||
EXPECT_EQ(allArtistsByName.front()->getId(), artistA.getId());
|
||||
EXPECT_EQ(allArtistsByName.back()->getId(), artistB.getId());
|
||||
|
||||
ASSERT_EQ(allArtistsBySortName.size(), 2);
|
||||
EXPECT_EQ(allArtistsBySortName.front()->getId(), artistB.getId());
|
||||
EXPECT_EQ(allArtistsBySortName.back()->getId(), artistA.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleArtistNonReleaseTracks)
|
||||
{
|
||||
ScopedArtist artist {session, "artist"};
|
||||
ScopedTrack track1 {session, "MyTrack1"};
|
||||
ScopedTrack track2 {session, "MyTrack2"};
|
||||
ScopedRelease release{session, "MyRelease"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_FALSE(artist->hasNonReleaseTracks(std::nullopt));
|
||||
|
||||
bool moreResults;
|
||||
const auto tracks {artist->getNonReleaseTracks(std::nullopt, std::nullopt, moreResults )};
|
||||
EXPECT_EQ(tracks.size(), 0);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackArtistLink::create(session, track1.get(), artist.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track2.get(), artist.get(), TrackArtistLinkType::Artist);
|
||||
|
||||
track1.get().modify()->setRelease(release.get());
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool moreResults;
|
||||
const auto tracks {artist->getNonReleaseTracks(std::nullopt, std::nullopt, moreResults )};
|
||||
EXPECT_TRUE(artist->hasNonReleaseTracks(std::nullopt));
|
||||
EXPECT_FALSE(moreResults);
|
||||
ASSERT_EQ(tracks.size(), 1);
|
||||
EXPECT_EQ(tracks.front()->getId(), track2.getId());
|
||||
}
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
|
||||
add_executable(test-database
|
||||
Artist.cpp
|
||||
Cluster.cpp
|
||||
DatabaseTest.cpp
|
||||
Release.cpp
|
||||
Track.cpp
|
||||
)
|
||||
|
||||
target_link_libraries(test-database PRIVATE
|
||||
lmsdatabase
|
||||
GTest::GTest
|
||||
)
|
||||
|
||||
if (NOT CMAKE_CROSSCOMPILING)
|
||||
gtest_discover_tests(test-database)
|
||||
endif()
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,183 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2021 Emeric Poupon
|
||||
*
|
||||
* This file is part of LMS.
|
||||
*
|
||||
* LMS 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.
|
||||
*
|
||||
* LMS 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 LMS. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <filesystem>
|
||||
#include <memory>
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "database/Artist.hpp"
|
||||
#include "database/Cluster.hpp"
|
||||
#include "database/Db.hpp"
|
||||
#include "database/Release.hpp"
|
||||
#include "database/Session.hpp"
|
||||
#include "database/Track.hpp"
|
||||
#include "database/TrackArtistLink.hpp"
|
||||
#include "database/TrackBookmark.hpp"
|
||||
#include "database/TrackList.hpp"
|
||||
#include "database/Types.hpp"
|
||||
#include "database/User.hpp"
|
||||
|
||||
template <typename T>
|
||||
class ScopedEntity
|
||||
{
|
||||
public:
|
||||
using IdType = typename T::IdType;
|
||||
|
||||
template <typename... Args>
|
||||
ScopedEntity(Database::Session& session, Args&& ...args)
|
||||
: _session {session}
|
||||
{
|
||||
auto transaction {_session.createUniqueTransaction()};
|
||||
|
||||
auto entity {T::create(_session, std::forward<Args>(args)...)};
|
||||
EXPECT_TRUE(entity);
|
||||
_id = entity->getId();
|
||||
}
|
||||
|
||||
~ScopedEntity()
|
||||
{
|
||||
auto transaction {_session.createUniqueTransaction()};
|
||||
|
||||
auto entity {T::getById(_session, _id)};
|
||||
entity.remove();
|
||||
}
|
||||
|
||||
ScopedEntity(const ScopedEntity&) = delete;
|
||||
ScopedEntity(ScopedEntity&&) = delete;
|
||||
ScopedEntity& operator=(const ScopedEntity&) = delete;
|
||||
ScopedEntity& operator=(ScopedEntity&&) = delete;
|
||||
|
||||
typename T::pointer lockAndGet()
|
||||
{
|
||||
auto transaction {_session.createSharedTransaction()};
|
||||
return get();
|
||||
}
|
||||
|
||||
typename T::pointer get()
|
||||
{
|
||||
_session.checkSharedLocked();
|
||||
|
||||
auto entity {T::getById(_session, _id)};
|
||||
EXPECT_TRUE(entity);
|
||||
return entity;
|
||||
}
|
||||
|
||||
typename T::pointer operator->()
|
||||
{
|
||||
return get();
|
||||
}
|
||||
|
||||
IdType getId() const { return _id; }
|
||||
|
||||
private:
|
||||
Database::Session& _session;
|
||||
IdType _id {};
|
||||
};
|
||||
|
||||
using ScopedArtist = ScopedEntity<Database::Artist>;
|
||||
using ScopedCluster = ScopedEntity<Database::Cluster>;
|
||||
using ScopedClusterType = ScopedEntity<Database::ClusterType>;
|
||||
using ScopedRelease = ScopedEntity<Database::Release>;
|
||||
using ScopedTrack = ScopedEntity<Database::Track>;
|
||||
using ScopedTrackBookmark = ScopedEntity<Database::TrackBookmark>;
|
||||
using ScopedTrackList = ScopedEntity<Database::TrackList>;
|
||||
using ScopedUser = ScopedEntity<Database::User>;
|
||||
|
||||
class ScopedFileDeleter final
|
||||
{
|
||||
public:
|
||||
ScopedFileDeleter(const std::filesystem::path& path) : _path {path} {}
|
||||
~ScopedFileDeleter() { std::filesystem::remove(_path); }
|
||||
|
||||
ScopedFileDeleter(const ScopedFileDeleter&) = delete;
|
||||
ScopedFileDeleter(ScopedFileDeleter&&) = delete;
|
||||
ScopedFileDeleter operator=(const ScopedFileDeleter&) = delete;
|
||||
ScopedFileDeleter operator=(ScopedFileDeleter&&) = delete;
|
||||
|
||||
private:
|
||||
const std::filesystem::path _path;
|
||||
};
|
||||
|
||||
class TmpDatabase final
|
||||
{
|
||||
public:
|
||||
Database::Db& getDb() { return _db; }
|
||||
|
||||
private:
|
||||
const std::filesystem::path _tmpFile {std::tmpnam(nullptr)};
|
||||
ScopedFileDeleter fileDeleter {_tmpFile};
|
||||
Database::Db _db {_tmpFile};
|
||||
};
|
||||
|
||||
class DatabaseFixture : public ::testing::Test
|
||||
{
|
||||
public:
|
||||
~DatabaseFixture()
|
||||
{
|
||||
testDatabaseEmpty();
|
||||
}
|
||||
|
||||
public:
|
||||
static void SetUpTestCase()
|
||||
{
|
||||
_tmpDb = std::make_unique<TmpDatabase>();
|
||||
{
|
||||
Database::Session s {_tmpDb->getDb()};
|
||||
s.prepareTables();
|
||||
s.optimize();
|
||||
|
||||
// remove default created entries
|
||||
{
|
||||
auto transaction {s.createUniqueTransaction()};
|
||||
auto clusterTypes {Database::ClusterType::getAll(s)};
|
||||
for (auto& clusterType : clusterTypes)
|
||||
clusterType.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void TearDownTestCase()
|
||||
{
|
||||
_tmpDb.reset();
|
||||
}
|
||||
|
||||
private:
|
||||
void testDatabaseEmpty()
|
||||
{
|
||||
auto uniqueTransaction {session.createUniqueTransaction()};
|
||||
|
||||
EXPECT_TRUE(Database::Artist::getAll(session, Database::Artist::SortMethod::ByName).empty());
|
||||
EXPECT_TRUE(Database::Cluster::getAll(session).empty());
|
||||
EXPECT_TRUE(Database::ClusterType::getAll(session).empty());
|
||||
EXPECT_TRUE(Database::Release::getAll(session).empty());
|
||||
EXPECT_TRUE(Database::Track::getAll(session).empty());
|
||||
EXPECT_TRUE(Database::TrackBookmark::getAll(session).empty());
|
||||
EXPECT_TRUE(Database::TrackList::getAll(session).empty());
|
||||
EXPECT_TRUE(Database::User::getAll(session).empty());
|
||||
}
|
||||
|
||||
static inline std::unique_ptr<TmpDatabase> _tmpDb {};
|
||||
|
||||
public:
|
||||
Database::Session session {_tmpDb->getDb()};
|
||||
};
|
||||
|
||||
@@ -1,410 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2019 Emeric Poupon
|
||||
*
|
||||
* This file is part of LMS.
|
||||
*
|
||||
* LMS 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.
|
||||
*
|
||||
* LMS 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 LMS. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <list>
|
||||
|
||||
#include "Common.hpp"
|
||||
|
||||
using namespace Database;
|
||||
|
||||
TEST_F(DatabaseFixture, MultiTracksSingleArtistSingleRelease)
|
||||
{
|
||||
constexpr std::size_t nbTracks {10};
|
||||
std::list<ScopedTrack> tracks;
|
||||
ScopedArtist artist {session, "MyArtst"};
|
||||
ScopedRelease release {session, "MyRelease"};
|
||||
|
||||
for (std::size_t i {}; i < nbTracks; ++i)
|
||||
{
|
||||
tracks.emplace_back(session, "MyTrack" + std::to_string(i));
|
||||
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackArtistLink::create(session, tracks.back().get(), artist.get(), TrackArtistLinkType::Artist);
|
||||
tracks.back().get().modify()->setRelease(release.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_TRUE(Release::getAllOrphans(session).empty());
|
||||
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_EQ(artist->getReleaseCount(), 1);
|
||||
ASSERT_EQ(artist->getReleases().size(), 1);
|
||||
EXPECT_EQ(artist->getReleases().front()->getId(), release.getId());
|
||||
|
||||
EXPECT_EQ(release->getTracks().size(), nbTracks);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtist)
|
||||
{
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
ScopedRelease release {session, "MyRelease"};
|
||||
ScopedArtist artist {session, "MyArtist"};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
auto trackArtistLink {TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist)};
|
||||
track.get().modify()->setRelease(release.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
auto releases {artist->getReleases()};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release.getId());
|
||||
|
||||
EXPECT_EQ(artist->getReleaseCount(), 1);
|
||||
|
||||
auto artists {release->getArtists()};
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
ASSERT_EQ(artists.front()->getId(), artist.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleUser)
|
||||
{
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_TRUE(User::getAll(session).empty());
|
||||
EXPECT_TRUE(User::getAllIds(session).empty());
|
||||
}
|
||||
|
||||
ScopedUser user {session, "MyUser"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_EQ(user->getQueuedTrackList(session)->getCount(), 0);
|
||||
EXPECT_EQ(User::getAll(session).size(), 1);
|
||||
EXPECT_EQ(User::getAllIds(session).size(), 1);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleStarredArtist)
|
||||
{
|
||||
ScopedArtist artist {session, "MyArtist"};
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
ScopedUser user {session, "MyUser"};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
EXPECT_FALSE(user->hasStarredArtist(artist.get()));
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
auto trackArtistLink {TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist)};
|
||||
user.get().modify()->starArtist(artist.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_TRUE(user->hasStarredArtist(artist.get()));
|
||||
|
||||
bool hasMore {};
|
||||
auto artists {Artist::getStarred(session, user.get(), {}, std::nullopt, Artist::SortMethod::BySortName, std::nullopt, hasMore)};
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist.getId());
|
||||
EXPECT_FALSE(hasMore);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleStarredRelease)
|
||||
{
|
||||
ScopedRelease release {session, "MyRelease"};
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
ScopedUser user {session, "MyUser"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_FALSE(user->hasStarredRelease(release.get()));
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track.get().modify()->setRelease(release.get());
|
||||
user.get().modify()->starRelease(release.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_TRUE(user->hasStarredRelease(release.get()));
|
||||
|
||||
bool hasMore {};
|
||||
auto releases {Release::getStarred(session, user.get(), {}, std::nullopt, hasMore)};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release.getId());
|
||||
EXPECT_FALSE(hasMore);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleStarredTrack)
|
||||
{
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
ScopedUser user {session, "MyUser"};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
EXPECT_FALSE(user->hasStarredTrack(track.get()));
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
user.get().modify()->starTrack(track.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
EXPECT_TRUE(user->hasStarredTrack(track.get()));
|
||||
|
||||
bool hasMore {};
|
||||
auto tracks {Track::getStarred(session, user.get(), {}, std::nullopt, hasMore)};
|
||||
ASSERT_EQ(tracks.size(), 1);
|
||||
EXPECT_EQ(tracks.front()->getId(), track.getId());
|
||||
EXPECT_FALSE(hasMore);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackList)
|
||||
{
|
||||
ScopedUser user {session, "MyUser"};
|
||||
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto trackLists {TrackList::getAll(session, user.get(), TrackList::Type::Playlist)};
|
||||
ASSERT_EQ(trackLists.size(), 1);
|
||||
EXPECT_EQ(trackLists.front()->getId(), trackList.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackListMultipleTrack)
|
||||
{
|
||||
ScopedUser user {session, "MyUser"};
|
||||
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
|
||||
std::list<ScopedTrack> tracks;
|
||||
|
||||
for (std::size_t i {}; i < 10; ++i)
|
||||
{
|
||||
tracks.emplace_back(session, "MyTrack" + std::to_string(i));
|
||||
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
TrackListEntry::create(session, tracks.back().get(), trackList.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
ASSERT_EQ(trackList->getCount(), tracks.size());
|
||||
const auto trackIds {trackList->getTrackIds()};
|
||||
for (auto trackId : trackIds)
|
||||
EXPECT_TRUE(std::any_of(std::cbegin(tracks), std::cend(tracks), [trackId](const ScopedTrack& track) { return track.getId() == trackId; }));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackListMultipleTrackDateTime)
|
||||
{
|
||||
ScopedUser user {session, "MyUser"};
|
||||
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
|
||||
ScopedTrack track1 {session, "MyTrack1"};
|
||||
ScopedTrack track2 {session, "MyTrack2"};
|
||||
ScopedTrack track3 {session, "MyTrack3"};
|
||||
|
||||
{
|
||||
Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
TrackListEntry::create(session, track1.get(), trackList.get(), now);
|
||||
TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(-1));
|
||||
TrackListEntry::create(session, track3.get(), trackList.get(), now.addSecs(1));
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool moreResults;
|
||||
const auto tracks {trackList.get()->getTracksReverse({}, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(tracks.size(), 3);
|
||||
EXPECT_EQ(tracks.front()->getId(), track3.getId());
|
||||
EXPECT_EQ(tracks.back()->getId(), track2.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackListMultipleTrackRecentlyPlayed)
|
||||
{
|
||||
ScopedUser user {session, "MyUser"};
|
||||
ScopedTrackList trackList {session, "MyTrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
|
||||
ScopedTrack track1 {session, "MyTrack1"};
|
||||
ScopedTrack track2 {session, "MyTrack1"};
|
||||
ScopedArtist artist1 {session, "MyArtist1"};
|
||||
ScopedArtist artist2 {session, "MyArtist2"};
|
||||
ScopedRelease release1 {session, "MyRelease1"};
|
||||
ScopedRelease release2 {session, "MyRelease2"};
|
||||
|
||||
const Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track1.get().modify()->setRelease(release1.get());
|
||||
track2.get().modify()->setRelease(release2.get());
|
||||
TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
|
||||
TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
|
||||
}
|
||||
{
|
||||
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool moreResults {};
|
||||
EXPECT_TRUE(trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults).empty());
|
||||
EXPECT_TRUE(trackList->getReleasesReverse({}, std::nullopt, moreResults).empty());
|
||||
EXPECT_TRUE(trackList->getTracksReverse({}, std::nullopt, moreResults).empty());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackListEntry::create(session, track1.get(), trackList.get(), now);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool moreResults {};
|
||||
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(artists.size(), 1);
|
||||
EXPECT_EQ(artists.front()->getId(), artist1.getId());
|
||||
|
||||
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release1.getId());
|
||||
|
||||
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
|
||||
EXPECT_EQ(tracks.size(), 1);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(1));
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool moreResults {};
|
||||
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(artists.size(), 2);
|
||||
EXPECT_EQ(artists[0]->getId(), artist2.getId());
|
||||
EXPECT_EQ(artists[1]->getId(), artist1.getId());
|
||||
|
||||
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(releases.size(), 2);
|
||||
EXPECT_EQ(releases[0]->getId(), release2.getId());
|
||||
EXPECT_EQ(releases[1]->getId(), release1.getId());
|
||||
|
||||
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(tracks.size(), 2);
|
||||
EXPECT_EQ(tracks[0]->getId(), track2.getId());
|
||||
EXPECT_EQ(tracks[1]->getId(), track1.getId());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
TrackListEntry::create(session, track1.get(), trackList.get(), now.addSecs(2));
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool moreResults {};
|
||||
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(artists.size(), 2);
|
||||
EXPECT_EQ(artists[0]->getId(), artist1.getId());
|
||||
EXPECT_EQ(artists[1]->getId(), artist2.getId());
|
||||
|
||||
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(releases.size(), 2);
|
||||
EXPECT_EQ(releases[0]->getId(), release1.getId());
|
||||
EXPECT_EQ(releases[1]->getId(), release2.getId());
|
||||
|
||||
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
|
||||
ASSERT_EQ(tracks.size(), 2);
|
||||
EXPECT_EQ(tracks[0]->getId(), track1.getId());
|
||||
EXPECT_EQ(tracks[1]->getId(), track2.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackSingleUserSingleBookmark)
|
||||
{
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
ScopedUser user {session, "MyUser"};
|
||||
ScopedTrackBookmark bookmark {session, user.lockAndGet(), track.lockAndGet()};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
bookmark.get().modify()->setComment("MyComment");
|
||||
bookmark.get().modify()->setOffset(std::chrono::milliseconds {5});
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_EQ(TrackBookmark::getAll(session).size(), 1);
|
||||
|
||||
const auto bookmarks {TrackBookmark::getByUser(session, user.get())};
|
||||
ASSERT_EQ(bookmarks.size(), 1);
|
||||
EXPECT_EQ(bookmarks.back(), bookmark.get());
|
||||
}
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto userBookmark {TrackBookmark::getByUser(session, user.get(), track.get())};
|
||||
ASSERT_TRUE(userBookmark);
|
||||
EXPECT_EQ(userBookmark, bookmark.get());
|
||||
|
||||
EXPECT_EQ(userBookmark->getOffset(), std::chrono::milliseconds {5});
|
||||
EXPECT_EQ(userBookmark->getComment(), "MyComment");
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@@ -1,363 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2021 Emeric Poupon
|
||||
*
|
||||
* This file is part of LMS.
|
||||
*
|
||||
* LMS 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.
|
||||
*
|
||||
* LMS 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 LMS. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "Common.hpp"
|
||||
|
||||
using namespace Database;
|
||||
|
||||
TEST_F(DatabaseFixture, SingleRelease)
|
||||
{
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_FALSE(Release::exists(session, 0));
|
||||
EXPECT_FALSE(Release::exists(session, 1));
|
||||
}
|
||||
|
||||
ScopedRelease release {session, "MyRelease"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_TRUE(Release::exists(session, release.getId()));
|
||||
|
||||
auto releases {Release::getAllOrphans(session)};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release.getId());
|
||||
|
||||
releases = Release::getAll(session);
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release.getId());
|
||||
EXPECT_EQ(release->getDuration(), std::chrono::seconds {0});
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackSingleRelease)
|
||||
{
|
||||
ScopedRelease release {session, "MyRelease"};
|
||||
|
||||
{
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track.get().modify()->setRelease(release.get());
|
||||
track.get().modify()->setName("MyTrackName");
|
||||
release.get().modify()->setName("MyReleaseName");
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_TRUE(Release::getAllOrphans(session).empty());
|
||||
|
||||
EXPECT_EQ(release->getTracksCount(), 1);
|
||||
ASSERT_EQ(release->getTracks().size(), 1);
|
||||
EXPECT_EQ(release->getTracks().front()->getId(), track.getId());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
ASSERT_TRUE(track->getRelease());
|
||||
EXPECT_EQ(track->getRelease()->getId(), release.getId());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
auto tracks {Track::getByNameAndReleaseName(session, "MyTrackName", "MyReleaseName")};
|
||||
ASSERT_EQ(tracks.size(), 1);
|
||||
EXPECT_EQ(tracks.front()->getId(), track.getId());
|
||||
}
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
auto tracks {Track::getByNameAndReleaseName(session, "MyTrackName", "MyReleaseFoo")};
|
||||
EXPECT_EQ(tracks.size(), 0);
|
||||
}
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
auto tracks {Track::getByNameAndReleaseName(session, "MyTrackFoo", "MyReleaseName")};
|
||||
EXPECT_EQ(tracks.size(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
EXPECT_TRUE(release->getTracks().empty());
|
||||
|
||||
auto releases {Release::getAllOrphans(session)};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, MulitpleReleaseSearchByName)
|
||||
{
|
||||
ScopedRelease release1 {session, "MyRelease"};
|
||||
ScopedRelease release2 {session, "MyRelease%"};
|
||||
ScopedRelease release3 {session, "%MyRelease"};
|
||||
ScopedRelease release4 {session, "MyRelease%Foo"};
|
||||
ScopedRelease release5 {session, "Foo%MyRelease"};
|
||||
ScopedRelease release6 {session, "_yRelease"};
|
||||
|
||||
// filters does not work on orphans
|
||||
ScopedTrack track1 {session, "MyTrack"};
|
||||
ScopedTrack track2 {session, "MyTrack"};
|
||||
ScopedTrack track3 {session, "MyTrack"};
|
||||
ScopedTrack track4 {session, "MyTrack"};
|
||||
ScopedTrack track5 {session, "MyTrack"};
|
||||
ScopedTrack track6 {session, "MyTrack"};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track1.get().modify()->setRelease(release1.get());
|
||||
track2.get().modify()->setRelease(release2.get());
|
||||
track3.get().modify()->setRelease(release3.get());
|
||||
track4.get().modify()->setRelease(release4.get());
|
||||
track5.get().modify()->setRelease(release5.get());
|
||||
track6.get().modify()->setRelease(release6.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool more;
|
||||
{
|
||||
const auto releases {Release::getByFilter(session, {}, {"Release"}, std::nullopt, more)};
|
||||
EXPECT_EQ(releases.size(), 6);
|
||||
}
|
||||
|
||||
{
|
||||
const auto releases {Release::getByFilter(session, {}, {"MyRelease"}, std::nullopt, more)};
|
||||
EXPECT_EQ(releases.size(), 5);
|
||||
EXPECT_TRUE(std::none_of(std::cbegin(releases), std::cend(releases), [&](const Release::pointer& release) { return release->getId() == release6.getId(); }));
|
||||
}
|
||||
{
|
||||
const auto releases {Release::getByFilter(session, {}, {"MyRelease%"}, std::nullopt, more)};
|
||||
ASSERT_EQ(releases.size(), 2);
|
||||
EXPECT_EQ(releases[0]->getId(), release2.getId());
|
||||
EXPECT_EQ(releases[1]->getId(), release4.getId());
|
||||
}
|
||||
{
|
||||
const auto releases {Release::getByFilter(session, {}, {"%MyRelease"}, std::nullopt, more)};
|
||||
ASSERT_EQ(releases.size(), 2);
|
||||
EXPECT_EQ(releases[0]->getId(), release3.getId());
|
||||
EXPECT_EQ(releases[1]->getId(), release5.getId());
|
||||
}
|
||||
{
|
||||
const auto releases {Release::getByFilter(session, {}, {"Foo%MyRelease"}, std::nullopt, more)};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases[0]->getId(), release5.getId());
|
||||
}
|
||||
{
|
||||
const auto releases {Release::getByFilter(session, {}, {"MyRelease%Foo"}, std::nullopt, more)};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases[0]->getId(), release4.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
|
||||
{
|
||||
ScopedRelease release1 {session, "MyRelease"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_FALSE(release1->getTotalTrack());
|
||||
EXPECT_FALSE(release1->getTotalDisc());
|
||||
}
|
||||
|
||||
ScopedTrack track1 {session, "MyTrack"};
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track1.get().modify()->setRelease(release1.get());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_FALSE(release1->getTotalTrack());
|
||||
EXPECT_FALSE(release1->getTotalDisc());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track1.get().modify()->setTotalTrack(36);
|
||||
track1.get().modify()->setTotalDisc(6);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
ASSERT_TRUE(release1->getTotalTrack());
|
||||
EXPECT_EQ(*release1->getTotalTrack(), 36);
|
||||
ASSERT_TRUE(release1->getTotalDisc());
|
||||
EXPECT_EQ(*release1->getTotalDisc(), 6);
|
||||
}
|
||||
|
||||
ScopedTrack track2 {session, "MyTrack2"};
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track2.get().modify()->setRelease(release1.get());
|
||||
track2.get().modify()->setTotalTrack(37);
|
||||
track2.get().modify()->setTotalDisc(67);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
ASSERT_TRUE(release1->getTotalTrack());
|
||||
EXPECT_EQ(*release1->getTotalTrack(), 37);
|
||||
ASSERT_TRUE(release1->getTotalDisc());
|
||||
EXPECT_EQ(*release1->getTotalDisc(), 67);
|
||||
}
|
||||
|
||||
ScopedRelease release2 {session, "MyRelease2"};
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_FALSE(release2->getTotalTrack());
|
||||
EXPECT_FALSE(release2->getTotalDisc());
|
||||
}
|
||||
|
||||
ScopedTrack track3 {session, "MyTrack3"};
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track3.get().modify()->setRelease(release2.get());
|
||||
track3.get().modify()->setTotalTrack(7);
|
||||
track3.get().modify()->setTotalDisc(5);
|
||||
}
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
ASSERT_TRUE(release1->getTotalTrack());
|
||||
EXPECT_EQ(*release1->getTotalTrack(), 37);
|
||||
ASSERT_TRUE(release1->getTotalDisc());
|
||||
EXPECT_EQ(*release1->getTotalDisc(), 67);
|
||||
ASSERT_TRUE(release2->getTotalTrack());
|
||||
EXPECT_EQ(*release2->getTotalTrack(), 7);
|
||||
ASSERT_TRUE(release2->getTotalDisc());
|
||||
EXPECT_EQ(*release2->getTotalDisc(), 5);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
|
||||
{
|
||||
ScopedRelease release1 {session, "MyRelease1"};
|
||||
ScopedRelease release2 {session, "MyRelease2"};
|
||||
|
||||
ScopedTrack track1A {session, "MyTrack1A"};
|
||||
ScopedTrack track1B {session, "MyTrack1B"};
|
||||
ScopedTrack track2A {session, "MyTrack2A"};
|
||||
ScopedTrack track2B {session, "MyTrack2B"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_FALSE(release1->getFirstTrack());
|
||||
EXPECT_FALSE(release2->getFirstTrack());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track1A.get().modify()->setRelease(release1.get());
|
||||
track1B.get().modify()->setRelease(release1.get());
|
||||
track2A.get().modify()->setRelease(release2.get());
|
||||
track2B.get().modify()->setRelease(release2.get());
|
||||
|
||||
track1A.get().modify()->setTrackNumber(1);
|
||||
track1B.get().modify()->setTrackNumber(2);
|
||||
|
||||
track2A.get().modify()->setDiscNumber(2);
|
||||
track2A.get().modify()->setTrackNumber(1);
|
||||
track2B.get().modify()->setTrackNumber(2);
|
||||
track2B.get().modify()->setDiscNumber(1);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_TRUE(release1->getFirstTrack());
|
||||
EXPECT_TRUE(release2->getFirstTrack());
|
||||
|
||||
EXPECT_EQ(release1->getFirstTrack()->getId(), track1A.getId());
|
||||
EXPECT_EQ(release2->getFirstTrack()->getId(), track2B.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, MultiTracksSingleReleaseDate)
|
||||
{
|
||||
ScopedRelease release1 {session, "MyRelease1"};
|
||||
ScopedRelease release2 {session, "MyRelease2"};
|
||||
const Wt::WDate release1Date {Wt::WDate {1994, 2, 3}};
|
||||
const Wt::WDate release1OriginalDate {Wt::WDate {1993, 4, 5}};
|
||||
|
||||
ScopedTrack track1A {session, "MyTrack1A"};
|
||||
ScopedTrack track1B {session, "MyTrack1B"};
|
||||
ScopedTrack track2A {session, "MyTrack2A"};
|
||||
ScopedTrack track2B {session, "MyTrack2B"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
const auto releases {Release::getByYear(session, 0, 3000)};
|
||||
EXPECT_EQ(releases.size(), 0);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
|
||||
track1A.get().modify()->setRelease(release1.get());
|
||||
track1B.get().modify()->setRelease(release1.get());
|
||||
track2A.get().modify()->setRelease(release2.get());
|
||||
track2B.get().modify()->setRelease(release2.get());
|
||||
|
||||
|
||||
track1A.get().modify()->setDate(release1Date);
|
||||
track1B.get().modify()->setDate(release1Date);
|
||||
track1A.get().modify()->setOriginalDate(release1OriginalDate);
|
||||
track1B.get().modify()->setOriginalDate(release1OriginalDate);
|
||||
|
||||
EXPECT_EQ(release1.get()->getReleaseYear(), release1Date.year());
|
||||
EXPECT_EQ(release1.get()->getReleaseYear(true), release1OriginalDate.year());
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
auto releases {Release::getByYear(session, 1950, 2000)};
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release1.getId());
|
||||
|
||||
releases = Release::getByYear(session, 1994, 1994);
|
||||
ASSERT_EQ(releases.size(), 1);
|
||||
EXPECT_EQ(releases.front()->getId(), release1.getId());
|
||||
|
||||
releases = Release::getByYear(session, 1993, 1993);
|
||||
ASSERT_EQ(releases.size(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,119 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2021 Emeric Poupon
|
||||
*
|
||||
* This file is part of LMS.
|
||||
*
|
||||
* LMS 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.
|
||||
*
|
||||
* LMS 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 LMS. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "Common.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
using namespace Database;
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrack)
|
||||
{
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_EQ(Track::getCount(session), 0);
|
||||
EXPECT_FALSE(Track::exists(session, 0));
|
||||
}
|
||||
|
||||
ScopedTrack track {session, "MyTrackFile"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
EXPECT_EQ(Track::getAll(session).size(), 1);
|
||||
EXPECT_EQ(Track::getCount(session), 1);
|
||||
EXPECT_TRUE(Track::exists(session, track.getId()));
|
||||
auto myTrack {Track::getById(session, track.getId())};
|
||||
ASSERT_TRUE(myTrack);
|
||||
EXPECT_EQ(myTrack->getId(), track.getId());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
|
||||
{
|
||||
ScopedTrack track1 {session, ""};
|
||||
ScopedTrack track2 {session, ""};
|
||||
ScopedTrack track3 {session, ""};
|
||||
ScopedTrack track4 {session, ""};
|
||||
ScopedTrack track5 {session, ""};
|
||||
ScopedTrack track6 {session, ""};
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
track1.get().modify()->setName("MyTrack");
|
||||
track2.get().modify()->setName("MyTrack%");
|
||||
track3.get().modify()->setName("MyTrack%Foo");
|
||||
track4.get().modify()->setName("%MyTrack");
|
||||
track5.get().modify()->setName("Foo%MyTrack");
|
||||
track6.get().modify()->setName("M_Track");
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
|
||||
bool more;
|
||||
{
|
||||
const auto tracks {Track::getByFilter(session, {}, {"Track"}, std::nullopt, more)};
|
||||
EXPECT_EQ(tracks.size(), 6);
|
||||
}
|
||||
{
|
||||
const auto tracks {Track::getByFilter(session, {}, {"MyTrack"}, std::nullopt, more)};
|
||||
EXPECT_EQ(tracks.size(), 5);
|
||||
EXPECT_TRUE(std::none_of(std::cbegin(tracks), std::cend(tracks), [&](const Track::pointer& track) { return track->getId() == track6.getId(); }));
|
||||
}
|
||||
{
|
||||
const auto tracks {Track::getByFilter(session, {}, {"MyTrack%"}, std::nullopt, more)};
|
||||
ASSERT_EQ(tracks.size(), 2);
|
||||
EXPECT_EQ(tracks[0]->getId(), track2.getId());
|
||||
EXPECT_EQ(tracks[1]->getId(), track3.getId());
|
||||
}
|
||||
{
|
||||
const auto tracks {Track::getByFilter(session, {}, {"%MyTrack"}, std::nullopt, more)};
|
||||
ASSERT_EQ(tracks.size(), 2);
|
||||
EXPECT_EQ(tracks[0]->getId(), track4.getId());
|
||||
EXPECT_EQ(tracks[1]->getId(), track5.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DatabaseFixture, SingleTrackDate)
|
||||
{
|
||||
ScopedTrack track {session, "MyTrack"};
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_EQ(track->getYear(), std::nullopt);
|
||||
EXPECT_EQ(track->getOriginalYear(), std::nullopt);
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createUniqueTransaction()};
|
||||
track.get().modify()->setDate(Wt::WDate {1995, 5, 5});
|
||||
track.get().modify()->setOriginalDate(Wt::WDate {1994, 2, 2});
|
||||
}
|
||||
|
||||
{
|
||||
auto transaction {session.createSharedTransaction()};
|
||||
EXPECT_EQ(track->getYear(), 1995);
|
||||
EXPECT_EQ(track->getOriginalYear(), 1994);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user