Make it possible for the LibraryBackend to be mocked, and add a simple test for Library.

src/CMakeLists.txt

@@ -60,6 +60,7 @@ set(CLEMENTINE-SOURCES
     xspfparser.cpp
     globalshortcuts/globalshortcuts.cpp
     fixlastfm.cpp
+    backgroundthread.cpp
 )
 
 # Header files that have Q_OBJECT in

src/albumcovermanager.cpp

@@ -22,7 +22,7 @@ const char* AlbumCoverManager::kSettingsGroup = "CoverManager";
 AlbumCoverManager::AlbumCoverManager(QNetworkAccessManager* network, QWidget *parent)
   : QDialog(parent),
     constructed_(false),
-    cover_loader_(new BackgroundThread<AlbumCoverLoader>(this)),
+    cover_loader_(new BackgroundThreadImplementation<AlbumCoverLoader, AlbumCoverLoader>(this)),
     cover_fetcher_(new AlbumCoverFetcher(network, this)),
     artist_icon_(":/artist.png"),
     all_artists_icon_(":/album.png"),
@@ -89,7 +89,7 @@ AlbumCoverManager::AlbumCoverManager(QNetworkAccessManager* network, QWidget *pa
     ui_.splitter->setSizes(QList<int>() << 200 << width() - 200);
   }
 
-  cover_loader_->start();
+  cover_loader_->Start();
   constructed_ = true;
 }
 
@@ -102,7 +102,7 @@ void AlbumCoverManager::CoverLoaderInitialised() {
           SLOT(CoverImageLoaded(quint64,QImage)));
 }
 
-void AlbumCoverManager::SetBackend(boost::shared_ptr<LibraryBackend> backend) {
+void AlbumCoverManager::SetBackend(boost::shared_ptr<LibraryBackendInterface> backend) {
   backend_ = backend;
 
   if (isVisible())
@@ -166,7 +166,7 @@ void AlbumCoverManager::ArtistChanged(QListWidgetItem* current) {
 
   // Get the list of albums.  How we do it depends on what thing we have
   // selected in the artist list.
-  LibraryBackend::AlbumList albums;
+  LibraryBackendInterface::AlbumList albums;
   switch (current->type()) {
     case Various_Artists: albums = backend_->GetCompilationAlbums(); break;
     case Specific_Artist: albums = backend_->GetAlbumsByArtist(current->text()); break;
@@ -174,7 +174,7 @@ void AlbumCoverManager::ArtistChanged(QListWidgetItem* current) {
     default:              albums = backend_->GetAllAlbums(); break;
   }
 
-  foreach (const LibraryBackend::Album& info, albums) {
+  foreach (const LibraryBackendInterface::Album& info, albums) {
     // Don't show songs without an album, obviously
     if (info.album_name.isEmpty())
       continue;

src/albumcovermanager.h

@@ -10,7 +10,7 @@
 #include "backgroundthread.h"
 #include "albumcoverloader.h"
 
-class LibraryBackend;
+class LibraryBackendInterface;
 class AlbumCoverFetcher;
 
 class QNetworkAccessManager;
@@ -26,7 +26,7 @@ class AlbumCoverManager : public QDialog {
   void Reset();
 
  public slots:
-  void SetBackend(boost::shared_ptr<LibraryBackend> backend);
+  void SetBackend(boost::shared_ptr<LibraryBackendInterface> backend);
 
  protected:
   void showEvent(QShowEvent *);
@@ -70,7 +70,7 @@ class AlbumCoverManager : public QDialog {
   bool constructed_;
 
   Ui::CoverManager ui_;
-  boost::shared_ptr<LibraryBackend> backend_;
+  boost::shared_ptr<LibraryBackendInterface> backend_;
 
   QAction* filter_all_;
   QAction* filter_with_covers_;

src/backgroundthread.cpp

@@ -0,0 +1,21 @@
+#include "backgroundthread.h"
+
+int BackgroundThreadBase::SetIOPriority() {
+#ifdef Q_OS_LINUX
+  return syscall(SYS_ioprio_set, IOPRIO_WHO_PROCESS, gettid(),
+                 4 | io_priority_ << IOPRIO_CLASS_SHIFT);
+#elif defined(Q_OS_DARWIN)
+  return setpriority(PRIO_DARWIN_THREAD, 0,
+                     io_priority_ == IOPRIO_CLASS_IDLE ? PRIO_DARWIN_BG : 0);
+#else
+  return 0;
+#endif
+}
+
+int BackgroundThreadBase::gettid() {
+#ifdef Q_OS_LINUX
+  return syscall(SYS_gettid);
+#else
+  return 0;
+#endif
+}

src/backgroundthread.h

@@ -13,11 +13,29 @@
 #  include <sys/resource.h>
 #endif
 
+// These classes are a bit confusing because they're trying to do so many
+// things:
+//  * Run a worker in a background thread
+//  * ... or maybe run it in the same thread if we're in a test
+//  * Use interfaces throughout, so the implementations can be mocked
+//  * Create concrete implementations of the interfaces when threads start
+//
+// The types you should use throughout your header files are:
+//   BackgroundThread<InterfaceType>
+//   BackgroundThreadFactory<InterfaceType>
+//
+// You should allow callers to set their own factory (which might return mocks
+// of your interface), and default to using a:
+//   BackgroundThreadFactoryImplementation<InterfaceType, DerivedType>
+
+
+// This is the base class.  We need one because moc doesn't like templated
+// classes.  This also deals with anything that doesn't depend on the type of
+// the worker.
 class BackgroundThreadBase : public QThread {
   Q_OBJECT
  public:
   BackgroundThreadBase(QObject* parent = 0) : QThread(parent), io_priority_(IOPRIO_CLASS_NONE) {}
-  virtual ~BackgroundThreadBase() {}
 
   // Borrowed from schedutils
   enum IoPriority {
@@ -28,14 +46,16 @@ class BackgroundThreadBase : public QThread {
   };
 
   void set_io_priority(IoPriority priority) { io_priority_ = priority; }
+  void set_cpu_priority(QThread::Priority priority) { cpu_priority_ = priority; }
+
+  virtual void Start() { QThread::start(cpu_priority_); }
 
  signals:
   void Initialised();
 
  protected:
-  // Borrowed from schedutils
+  int SetIOPriority();
-  static inline int ioprio_set(int which, int who, int ioprio);
+  static int gettid();
-  static inline int gettid();
 
   enum {
     IOPRIO_WHO_PROCESS = 1,
@@ -45,31 +65,61 @@ class BackgroundThreadBase : public QThread {
   static const int IOPRIO_CLASS_SHIFT = 13;
 
   IoPriority io_priority_;
+  QThread::Priority cpu_priority_;
 };
 
-template <typename T>
+// This is the templated class that stores and returns the worker object.
+template <typename InterfaceType>
 class BackgroundThread : public BackgroundThreadBase {
  public:
   BackgroundThread(QObject* parent = 0);
-  virtual ~BackgroundThread();
+  ~BackgroundThread();
 
-  boost::shared_ptr<T> Worker() const { return worker_; }
+  boost::shared_ptr<InterfaceType> Worker() const { return worker_; }
+
+ protected:
+  boost::shared_ptr<InterfaceType> worker_;
+};
+
+// This class actually creates an implementation of the worker object
+template <typename InterfaceType, typename DerivedType>
+class BackgroundThreadImplementation : public BackgroundThread<InterfaceType> {
+ public:
+  BackgroundThreadImplementation(QObject* parent = 0);
 
  protected:
   void run();
-
- private:
-  boost::shared_ptr<T> worker_;
 };
 
-template <typename T>
+
-BackgroundThread<T>::BackgroundThread(QObject *parent)
+// This is a pure virtual factory for creating threads.
+template <typename InterfaceType>
+class BackgroundThreadFactory {
+ public:
+  virtual ~BackgroundThreadFactory() {}
+  virtual BackgroundThread<InterfaceType>* GetThread(QObject* parent) = 0;
+};
+
+// This implementation of the factory returns a BackgroundThread that creates
+// the right derived types...
+template <typename InterfaceType, typename DerivedType>
+class BackgroundThreadFactoryImplementation : public BackgroundThreadFactory<InterfaceType> {
+ public:
+  BackgroundThread<InterfaceType>* GetThread(QObject* parent) {
+    return new BackgroundThreadImplementation<InterfaceType, DerivedType>(parent);
+  }
+};
+
+
+
+template <typename InterfaceType>
+BackgroundThread<InterfaceType>::BackgroundThread(QObject *parent)
   : BackgroundThreadBase(parent)
 {
 }
 
-template <typename T>
+template <typename InterfaceType>
-BackgroundThread<T>::~BackgroundThread() {
+BackgroundThread<InterfaceType>::~BackgroundThread() {
   if (isRunning()) {
     quit();
     if (wait(10000))
@@ -79,39 +129,27 @@ BackgroundThread<T>::~BackgroundThread() {
   }
 }
 
-template <typename T>
+template <typename InterfaceType, typename DerivedType>
-void BackgroundThread<T>::run() {
+BackgroundThreadImplementation<InterfaceType, DerivedType>::
-#ifdef Q_OS_LINUX
+    BackgroundThreadImplementation(QObject* parent)
-  if (io_priority_ != IOPRIO_CLASS_NONE) {
+      : BackgroundThread<InterfaceType>(parent)
-    ioprio_set(IOPRIO_WHO_PROCESS, gettid(),
+{
-               4 | io_priority_ << IOPRIO_CLASS_SHIFT);
-  }
-#endif
-
-  worker_.reset(new T);
-
-  emit Initialised();
-  exec();
-
-  worker_.reset();
 }
 
-int BackgroundThreadBase::ioprio_set(int which, int who, int ioprio) {
+
-#ifdef Q_OS_LINUX
+template <typename InterfaceType, typename DerivedType>
-  return syscall(SYS_ioprio_set, which, who, ioprio);
+void BackgroundThreadImplementation<InterfaceType, DerivedType>::run() {
-#elif defined(Q_OS_DARWIN)
+  BackgroundThreadBase::SetIOPriority();
-  return setpriority(PRIO_DARWIN_THREAD, 0, ioprio == IOPRIO_CLASS_IDLE ? PRIO_DARWIN_BG : 0);
+
-#else
+  BackgroundThread<InterfaceType>::worker_.reset(new DerivedType);
-  return 0;
+
-#endif
+  emit BackgroundThreadBase::Initialised();
+  QThread::exec();
+
+  BackgroundThread<InterfaceType>::worker_.reset();
 }
 
-int BackgroundThreadBase::gettid() {
+
-#ifdef Q_OS_LINUX
+
-  return syscall(SYS_gettid);
-#else
-  return 0;
-#endif
-}
 
 #endif // BACKGROUNDTHREAD_H

src/library.cpp

@@ -13,31 +13,49 @@
 Library::Library(EngineBase* engine, QObject* parent)
   : SimpleTreeModel<LibraryItem>(new LibraryItem(this), parent),
     engine_(engine),
-    backend_(new BackgroundThread<LibraryBackend>(this)),
+    backend_factory_(new BackgroundThreadFactoryImplementation<LibraryBackendInterface, LibraryBackend>),
-    watcher_(new BackgroundThread<LibraryWatcher>(this)),
+    watcher_factory_(new BackgroundThreadFactoryImplementation<LibraryWatcher, LibraryWatcher>),
+    backend_(NULL),
+    watcher_(NULL),
     dir_model_(new LibraryDirectoryModel(this)),
+    waiting_for_threads_(2),
     artist_icon_(":artist.png"),
     album_icon_(":album.png"),
     no_cover_icon_(":nocover.png")
 {
   root_->lazy_loaded = true;
-
-  connect(backend_, SIGNAL(Initialised()), SLOT(BackendInitialised()));
-  connect(watcher_, SIGNAL(Initialised()), SLOT(WatcherInitialised()));
-  waiting_for_threads_ = 2;
 }
 
 Library::~Library() {
   delete root_;
 }
 
+void Library::set_backend_factory(BackgroundThreadFactory<LibraryBackendInterface>* factory) {
+  backend_factory_.reset(factory);
+}
+
+void Library::set_watcher_factory(BackgroundThreadFactory<LibraryWatcher>* factory) {
+  watcher_factory_.reset(factory);
+}
+
+void Library::Init() {
+  backend_ = backend_factory_->GetThread(this);
+  watcher_ = watcher_factory_->GetThread(this);
+
+  connect(backend_, SIGNAL(Initialised()), SLOT(BackendInitialised()));
+  connect(watcher_, SIGNAL(Initialised()), SLOT(WatcherInitialised()));
+}
+
 void Library::StartThreads() {
   Q_ASSERT(waiting_for_threads_);
+  Q_ASSERT(backend_);
+  Q_ASSERT(watcher_);
 
-  backend_->start();
+  backend_->Start();
 
   watcher_->set_io_priority(BackgroundThreadBase::IOPRIO_CLASS_IDLE);
-  watcher_->start(QThread::IdlePriority);
+  watcher_->set_cpu_priority(QThread::IdlePriority);
+  watcher_->Start();
 }
 
 void Library::BackendInitialised() {
@@ -375,7 +393,7 @@ void Library::LazyPopulate(LibraryItem* item) {
 
   switch (item->type) {
     case LibraryItem::Type_CompilationArtist:
-      foreach (const LibraryBackend::Album& album,
+      foreach (const LibraryBackendInterface::Album& album,
                backend_->Worker()->GetCompilationAlbums(query_options_))
         CreateAlbumNode(false, album.album_name, item, true, album.art_automatic, album.art_manual, album.artist);
       break;
@@ -386,7 +404,7 @@ void Library::LazyPopulate(LibraryItem* item) {
       break;
 
     case LibraryItem::Type_Artist:
-      foreach (const LibraryBackend::Album& album,
+      foreach (const LibraryBackendInterface::Album& album,
                backend_->Worker()->GetAlbumsByArtist(item->key, query_options_))
         CreateAlbumNode(false, album.album_name, item, false, album.art_automatic, album.art_manual, album.artist);
       break;

src/library.h

@@ -13,6 +13,8 @@
 #include "libraryitem.h"
 #include "simpletreemodel.h"
 
+#include <boost/scoped_ptr.hpp>
+
 class LibraryDirectoryModel;
 
 class Library : public SimpleTreeModel<LibraryItem> {
@@ -29,10 +31,15 @@ class Library : public SimpleTreeModel<LibraryItem> {
     Role_Artist,
   };
 
+  // Useful for tests.  The library takes ownership.
+  void set_backend_factory(BackgroundThreadFactory<LibraryBackendInterface>* factory);
+  void set_watcher_factory(BackgroundThreadFactory<LibraryWatcher>* factory);
+
+  void Init();
   void StartThreads();
 
   LibraryDirectoryModel* GetDirectoryModel() const { return dir_model_; }
-  boost::shared_ptr<LibraryBackend> GetBackend() const { return backend_->Worker(); }
+  boost::shared_ptr<LibraryBackendInterface> GetBackend() const { return backend_->Worker(); }
 
   // Get information about the library
   void GetChildSongs(LibraryItem* item, QList<QUrl>* urls, SongList* songs) const;
@@ -52,7 +59,7 @@ class Library : public SimpleTreeModel<LibraryItem> {
   void ScanStarted();
   void ScanFinished();
 
-  void BackendReady(boost::shared_ptr<LibraryBackend> backend);
+  void BackendReady(boost::shared_ptr<LibraryBackendInterface> backend);
 
  public slots:
   void SetFilterAge(int age);
@@ -96,7 +103,9 @@ class Library : public SimpleTreeModel<LibraryItem> {
 
  private:
   EngineBase* engine_;
-  BackgroundThread<LibraryBackend>* backend_;
+  boost::scoped_ptr<BackgroundThreadFactory<LibraryBackendInterface> > backend_factory_;
+  boost::scoped_ptr<BackgroundThreadFactory<LibraryWatcher> > watcher_factory_;
+  BackgroundThread<LibraryBackendInterface>* backend_;
   BackgroundThread<LibraryWatcher>* watcher_;
   LibraryDirectoryModel* dir_model_;
 

src/librarybackend.cpp

@@ -100,8 +100,13 @@ void LibraryBackend::SqliteLike(sqlite3_context* context, int argc, sqlite3_valu
   }
 }
 
+LibraryBackendInterface::LibraryBackendInterface(QObject *parent)
+  : QObject(parent)
+{
+}
+
 LibraryBackend::LibraryBackend(QObject* parent, const QString& database_name)
-  : QObject(parent),
+  : LibraryBackendInterface(parent),
     injected_database_name_(database_name)
 {
   QSettings s;

src/librarybackend.h

@@ -15,11 +15,11 @@
 
 #include "gtest/gtest_prod.h"
 
-class LibraryBackend : public QObject {
+class LibraryBackendInterface : public QObject {
   Q_OBJECT
 
  public:
-  LibraryBackend(QObject* parent = 0, const QString& database_name = QString());
+  LibraryBackendInterface(QObject* parent = 0);
 
   struct Album {
     QString artist;
@@ -30,6 +30,63 @@ class LibraryBackend : public QObject {
   };
   typedef QList<Album> AlbumList;
 
+  // Get a list of directories in the library.  Emits DirectoriesDiscovered.
+  virtual void LoadDirectoriesAsync() = 0;
+
+  // Counts the songs in the library.  Emits TotalSongCountUpdated
+  virtual void UpdateTotalSongCountAsync() = 0;
+
+  virtual SongList FindSongsInDirectory(int id) = 0;
+
+  virtual QStringList GetAllArtists(const QueryOptions& opt = QueryOptions()) = 0;
+  virtual SongList GetSongs(const QString& artist, const QString& album, const QueryOptions& opt = QueryOptions()) = 0;
+
+  virtual bool HasCompilations(const QueryOptions& opt = QueryOptions()) = 0;
+  virtual SongList GetCompilationSongs(const QString& album, const QueryOptions& opt = QueryOptions()) = 0;
+
+  virtual AlbumList GetAllAlbums(const QueryOptions& opt = QueryOptions()) = 0;
+  virtual AlbumList GetAlbumsByArtist(const QString& artist, const QueryOptions& opt = QueryOptions()) = 0;
+  virtual AlbumList GetCompilationAlbums(const QueryOptions& opt = QueryOptions()) = 0;
+
+  virtual void UpdateManualAlbumArtAsync(const QString& artist, const QString& album, const QString& art) = 0;
+  virtual Album GetAlbumArt(const QString& artist, const QString& album) = 0;
+
+  virtual Song GetSongById(int id) = 0;
+
+  virtual void AddDirectory(const QString& path) = 0;
+  virtual void RemoveDirectory(const Directory& dir) = 0;
+
+  virtual void UpdateCompilationsAsync() = 0;
+
+ public slots:
+  virtual void LoadDirectories() = 0;
+  virtual void UpdateTotalSongCount() = 0;
+  virtual void AddOrUpdateSongs(const SongList& songs) = 0;
+  virtual void UpdateMTimesOnly(const SongList& songs) = 0;
+  virtual void DeleteSongs(const SongList& songs) = 0;
+  virtual void UpdateCompilations() = 0;
+  virtual void UpdateManualAlbumArt(const QString& artist, const QString& album, const QString& art) = 0;
+  virtual void ForceCompilation(const QString& artist, const QString& album, bool on) = 0;
+
+ signals:
+  void Error(const QString& message);
+
+  void DirectoriesDiscovered(const DirectoryList& directories);
+  void DirectoriesDeleted(const DirectoryList& directories);
+
+  void SongsDiscovered(const SongList& songs);
+  void SongsDeleted(const SongList& songs);
+
+  void TotalSongCountUpdated(int total);
+};
+
+
+class LibraryBackend : public LibraryBackendInterface {
+  Q_OBJECT
+
+ public:
+  LibraryBackend(QObject* parent = 0, const QString& database_name = QString());
+
   static const int kSchemaVersion;
 
   // This actually refers to the location of the sqlite database
@@ -73,17 +130,6 @@ class LibraryBackend : public QObject {
   void UpdateManualAlbumArt(const QString& artist, const QString& album, const QString& art);
   void ForceCompilation(const QString& artist, const QString& album, bool on);
 
- signals:
-  void Error(const QString& message);
-
-  void DirectoriesDiscovered(const DirectoryList& directories);
-  void DirectoriesDeleted(const DirectoryList& directories);
-
-  void SongsDiscovered(const SongList& songs);
-  void SongsDeleted(const SongList& songs);
-
-  void TotalSongCountUpdated(int total);
-
  private:
   struct CompilationInfo {
     CompilationInfo() : has_samplers(false), has_not_samplers(false) {}

src/librarydirectorymodel.cpp

@@ -7,7 +7,7 @@ LibraryDirectoryModel::LibraryDirectoryModel(QObject* parent)
 {
 }
 
-void LibraryDirectoryModel::SetBackend(boost::shared_ptr<LibraryBackend> backend) {
+void LibraryDirectoryModel::SetBackend(boost::shared_ptr<LibraryBackendInterface> backend) {
   backend_ = backend;
 
   connect(backend_.get(), SIGNAL(DirectoriesDiscovered(DirectoryList)), SLOT(DirectoriesDiscovered(DirectoryList)));

src/librarydirectorymodel.h

@@ -8,7 +8,7 @@
 
 #include "directory.h"
 
-class LibraryBackend;
+class LibraryBackendInterface;
 
 class LibraryDirectoryModel : public QStandardItemModel {
   Q_OBJECT
@@ -16,7 +16,7 @@ class LibraryDirectoryModel : public QStandardItemModel {
  public:
   LibraryDirectoryModel(QObject* parent = 0);
 
-  void SetBackend(boost::shared_ptr<LibraryBackend> backend);
+  void SetBackend(boost::shared_ptr<LibraryBackendInterface> backend);
   bool IsBackendReady() const { return backend_; }
 
   // To be called by GUIs
@@ -35,7 +35,7 @@ class LibraryDirectoryModel : public QStandardItemModel {
   static const int kIdRole = Qt::UserRole + 1;
 
   QIcon dir_icon_;
-  boost::shared_ptr<LibraryBackend> backend_;
+  boost::shared_ptr<LibraryBackendInterface> backend_;
 };
 
 #endif // LIBRARYDIRECTORYMODEL_H

src/librarywatcher.h

@@ -14,7 +14,7 @@
 class QFileSystemWatcher;
 class QTimer;
 
-class LibraryBackend;
+class LibraryBackendInterface;
 
 class LibraryWatcher : public QObject {
   Q_OBJECT
@@ -22,7 +22,7 @@ class LibraryWatcher : public QObject {
  public:
   LibraryWatcher(QObject* parent = 0);
 
-  void SetBackend(boost::shared_ptr<LibraryBackend> backend) { backend_ = backend; }
+  void SetBackend(boost::shared_ptr<LibraryBackendInterface> backend) { backend_ = backend; }
   void SetEngine(EngineBase* engine) { engine_ = engine; } // TODO: shared_ptr
 
  signals:
@@ -51,7 +51,7 @@ class LibraryWatcher : public QObject {
 
  private:
   EngineBase* engine_;
-  boost::shared_ptr<LibraryBackend> backend_;
+  boost::shared_ptr<LibraryBackendInterface> backend_;
 
   QFileSystemWatcher* fs_watcher_;
   QTimer* rescan_timer_;

src/mainwindow.cpp

@@ -179,8 +179,8 @@ MainWindow::MainWindow(QNetworkAccessManager* network, QWidget *parent)
   connect(library_, SIGNAL(TotalSongCountUpdated(int)), ui_.library_view, SLOT(TotalSongCountUpdated(int)));
   connect(library_, SIGNAL(ScanStarted()), SLOT(LibraryScanStarted()));
   connect(library_, SIGNAL(ScanFinished()), SLOT(LibraryScanFinished()));
-  connect(library_, SIGNAL(BackendReady(boost::shared_ptr<LibraryBackend>)),
+  connect(library_, SIGNAL(BackendReady(boost::shared_ptr<LibraryBackendInterface>)),
-          cover_manager_, SLOT(SetBackend(boost::shared_ptr<LibraryBackend>)));
+          cover_manager_, SLOT(SetBackend(boost::shared_ptr<LibraryBackendInterface>)));
 
   // Age filters
   QActionGroup* filter_age_group = new QActionGroup(this);
@@ -311,6 +311,7 @@ MainWindow::MainWindow(QNetworkAccessManager* network, QWidget *parent)
     show();
   }
 
+  library_->Init();
   library_->StartThreads();
 }
 

tests/CMakeLists.txt

@@ -31,10 +31,12 @@ target_link_libraries(gmock gtest)
 set(TESTUTILS-SOURCES
     test_utils.cpp
     mock_networkaccessmanager.cpp
-    mock_taglib.cpp)
+    mock_taglib.cpp
+)
 
 set(TESTUTILS-MOC-HEADERS
-    mock_networkaccessmanager.h)
+    mock_networkaccessmanager.h
+)
 
 qt4_wrap_cpp(TESTUTILS-SOURCES-MOC ${TESTUTILS-MOC-HEADERS})
 
@@ -45,6 +47,10 @@ add_custom_target(test
     echo "Running tests"
     WORKING_DIRECTORY ${CURRENT_BINARY_DIR}
 )
+add_custom_target(build_tests
+    WORKING_DIRECTORY ${CURRENT_BINARY_DIR}
+)
+add_dependencies(test build_tests)
 
 # Given a file foo_test.cpp, creates a target foo_test and adds it to the test target.
 macro(add_test_file test_source)
@@ -57,7 +63,7 @@ macro(add_test_file test_source)
     target_link_libraries(${TEST_NAME} gmock clementine_lib test_utils)
     add_custom_command(TARGET test POST_BUILD
         COMMAND ./${TEST_NAME})
-    add_dependencies(test ${TEST_NAME})
+    add_dependencies(build_tests ${TEST_NAME})
 endmacro (add_test_file)
 
 
@@ -66,3 +72,4 @@ add_test_file(song_test.cpp)
 add_test_file(librarybackend_test.cpp)
 add_test_file(albumcoverfetcher_test.cpp)
 add_test_file(xspfparser_test.cpp)
+add_test_file(library_test.cpp)

tests/library_test.cpp

@@ -0,0 +1,46 @@
+#include "test_utils.h"
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "library.h"
+#include "backgroundthread.h"
+#include "mock_backgroundthread.h"
+#include "mock_librarybackend.h"
+
+#include <boost/scoped_ptr.hpp>
+
+#include <QtDebug>
+#include <QThread>
+#include <QSignalSpy>
+
+using ::testing::_;
+using ::testing::Return;
+
+class LibraryTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    library_.reset(new Library(NULL, NULL));
+    library_->set_backend_factory(
+        new FakeBackgroundThreadFactory<LibraryBackendInterface, MockLibraryBackend>);
+    library_->set_watcher_factory(
+        new FakeBackgroundThreadFactory<LibraryWatcher, LibraryWatcher>);
+
+    library_->Init();
+
+    backend_ = static_cast<MockLibraryBackend*>(library_->GetBackend().get());
+  }
+
+  boost::scoped_ptr<Library> library_;
+  MockLibraryBackend* backend_;
+};
+
+TEST_F(LibraryTest, TestInitialisation) {
+  EXPECT_CALL(*backend_, LoadDirectoriesAsync());
+  EXPECT_CALL(*backend_, UpdateTotalSongCountAsync());
+  EXPECT_CALL(*backend_, HasCompilations(_))
+      .WillOnce(Return(false));
+  EXPECT_CALL(*backend_, GetAllArtists(_))
+      .WillOnce(Return(QStringList()));
+
+  library_->StartThreads();
+}

tests/main.cpp

@@ -1,13 +1,16 @@
 #include <gmock/gmock.h>
 
+#include <QApplication>
+
 #include "resources_env.h"
 #include "metatypes_env.h"
 
 int main(int argc, char** argv) {
   testing::InitGoogleMock(&argc, argv);
 
-  testing::AddGlobalTestEnvironment(new ResourcesEnvironment);
   testing::AddGlobalTestEnvironment(new MetatypesEnvironment);
+  QApplication a(argc, argv);
+  testing::AddGlobalTestEnvironment(new ResourcesEnvironment);
 
   return RUN_ALL_TESTS();
 }

tests/mock_backgroundthread.h

@@ -0,0 +1,28 @@
+#ifndef MOCK_BACKGROUNDTHREAD_H
+#define MOCK_BACKGROUNDTHREAD_H
+
+#include "backgroundthread.h"
+
+template <typename InterfaceType, typename DerivedType>
+class FakeBackgroundThread : public BackgroundThread<InterfaceType> {
+ public:
+  FakeBackgroundThread(QObject* parent) : BackgroundThread<InterfaceType>(parent) {
+    // We have to create the actual worker here instead of in Start() so that
+    // tests can set mock expectations on it before Initialised is emitted.
+    BackgroundThread<InterfaceType>::worker_.reset(new DerivedType);
+  }
+
+  void Start() {
+    emit BackgroundThreadBase::Initialised();
+  }
+};
+
+template <typename InterfaceType, typename DerivedType>
+class FakeBackgroundThreadFactory : public BackgroundThreadFactory<InterfaceType> {
+ public:
+  BackgroundThread<InterfaceType>* GetThread(QObject* parent) {
+    return new FakeBackgroundThread<InterfaceType, DerivedType>(parent);
+  }
+};
+
+#endif

tests/mock_librarybackend.h

@@ -0,0 +1,58 @@
+#ifndef MOCK_LIBRARYBACKEND_H
+#define MOCK_LIBRARYBACKEND_H
+
+#include "librarybackend.h"
+
+class MockLibraryBackend : public LibraryBackendInterface {
+ public:
+  MOCK_METHOD0(LoadDirectoriesAsync,
+      void());
+  MOCK_METHOD0(UpdateTotalSongCountAsync,
+      void());
+  MOCK_METHOD1(FindSongsInDirectory,
+      SongList(int id));
+  MOCK_METHOD1(GetAllArtists,
+      QStringList(const QueryOptions& opt));
+  MOCK_METHOD3(GetSongs,
+      SongList(const QString& artist, const QString& album, const QueryOptions& opt));
+  MOCK_METHOD1(HasCompilations,
+      bool(const QueryOptions& opt));
+  MOCK_METHOD2(GetCompilationSongs,
+      SongList(const QString& album, const QueryOptions& opt));
+  MOCK_METHOD1(GetAllAlbums,
+      AlbumList(const QueryOptions& opt));
+  MOCK_METHOD2(GetAlbumsByArtist,
+      AlbumList(const QString& artist, const QueryOptions& opt));
+  MOCK_METHOD1(GetCompilationAlbums,
+      AlbumList(const QueryOptions& opt));
+  MOCK_METHOD3(UpdateManualAlbumArtAsync,
+      void(const QString& artist, const QString& album, const QString& art));
+  MOCK_METHOD2(GetAlbumArt,
+      Album(const QString& artist, const QString& album));
+  MOCK_METHOD1(GetSongById,
+      Song(int id));
+  MOCK_METHOD1(AddDirectory,
+      void(const QString& path));
+  MOCK_METHOD1(RemoveDirectory,
+      void(const Directory& dir));
+  MOCK_METHOD0(UpdateCompilationsAsync,
+      void());
+  MOCK_METHOD0(LoadDirectories,
+      void());
+  MOCK_METHOD0(UpdateTotalSongCount,
+      void());
+  MOCK_METHOD1(AddOrUpdateSongs,
+      void(const SongList& songs));
+  MOCK_METHOD1(UpdateMTimesOnly,
+      void(const SongList& songs));
+  MOCK_METHOD1(DeleteSongs,
+      void(const SongList& songs));
+  MOCK_METHOD0(UpdateCompilations,
+      void());
+  MOCK_METHOD3(UpdateManualAlbumArt,
+      void(const QString& artist, const QString& album, const QString& art));
+  MOCK_METHOD3(ForceCompilation,
+      void(const QString& artist, const QString& album, bool on));
+};
+
+#endif