diff --git a/src/presentation/applicationmodel.h b/src/presentation/applicationmodel.h --- a/src/presentation/applicationmodel.h +++ b/src/presentation/applicationmodel.h @@ -49,10 +49,8 @@ class ApplicationModel : public QObject { Q_OBJECT - Q_PROPERTY(QAbstractItemModel* noteSourcesModel READ noteSourcesModel) - Q_PROPERTY(Domain::DataSource::Ptr defaultNoteDataSource READ defaultNoteDataSource WRITE setDefaultNoteDataSource) - Q_PROPERTY(QAbstractItemModel* taskSourcesModel READ taskSourcesModel) - Q_PROPERTY(Domain::DataSource::Ptr defaultTaskDataSource READ defaultTaskDataSource WRITE setDefaultTaskDataSource) + Q_PROPERTY(QAbstractItemModel* dataSourcesModel READ dataSourcesModel) + Q_PROPERTY(Domain::DataSource::Ptr defaultDataSource READ defaultDataSource WRITE setDefaultDataSource) Q_PROPERTY(QObject* availableSources READ availableSources) Q_PROPERTY(QObject* availablePages READ availablePages) Q_PROPERTY(QObject* currentPage READ currentPage WRITE setCurrentPage NOTIFY currentPageChanged) @@ -71,11 +69,8 @@ const Domain::TagRepository::Ptr &tagRepository, QObject *parent = Q_NULLPTR); - QAbstractItemModel *noteSourcesModel(); - Domain::DataSource::Ptr defaultNoteDataSource(); - - QAbstractItemModel *taskSourcesModel(); - Domain::DataSource::Ptr defaultTaskDataSource(); + QAbstractItemModel *dataSourcesModel(); + Domain::DataSource::Ptr defaultDataSource(); QObject *availableSources(); QObject *availablePages(); @@ -86,25 +81,28 @@ public slots: void setCurrentPage(QObject *page); - void setDefaultNoteDataSource(Domain::DataSource::Ptr source); - void setDefaultTaskDataSource(Domain::DataSource::Ptr source); + virtual void setDefaultDataSource(const Domain::DataSource::Ptr &source) = 0; void setErrorHandler(ErrorHandler *errorHandler); signals: void currentPageChanged(QObject *page); private: + virtual Domain::QueryResult::Ptr createDataSourceQueryResult() = 0; + virtual bool isDefaultSource(const Domain::DataSource::Ptr &source) = 0; virtual AvailablePagesModelInterface *createAvailablePagesModel() = 0; - Domain::QueryResult::Ptr noteSources(); - Domain::QueryResult::Ptr taskSources(); + Domain::QueryResult::Ptr dataSources(); QObject *m_availableSources; QObject *m_availablePages; QObject *m_currentPage; QObject *m_editor; protected: + Domain::QueryResult::Ptr m_dataSources; + QAbstractItemModel *m_dataSourcesModel; + Domain::ProjectQueries::Ptr m_projectQueries; Domain::ProjectRepository::Ptr m_projectRepository; @@ -117,12 +115,7 @@ Domain::TaskQueries::Ptr m_taskQueries; Domain::TaskRepository::Ptr m_taskRepository; - Domain::QueryResult::Ptr m_taskSources; - QAbstractItemModel *m_taskSourcesModel; - Domain::NoteRepository::Ptr m_noteRepository; - Domain::QueryResult::Ptr m_noteSources; - QAbstractItemModel *m_noteSourcesModel; Domain::TagQueries::Ptr m_tagQueries; Domain::TagRepository::Ptr m_tagRepository; diff --git a/src/presentation/applicationmodel.cpp b/src/presentation/applicationmodel.cpp --- a/src/presentation/applicationmodel.cpp +++ b/src/presentation/applicationmodel.cpp @@ -61,88 +61,51 @@ m_availablePages(Q_NULLPTR), m_currentPage(Q_NULLPTR), m_editor(Q_NULLPTR), + m_dataSourcesModel(Q_NULLPTR), m_projectQueries(projectQueries), m_projectRepository(projectRepository), m_contextQueries(contextQueries), m_contextRepository(contextRepository), m_sourceQueries(sourceQueries), m_sourceRepository(sourceRepository), m_taskQueries(taskQueries), m_taskRepository(taskRepository), - m_taskSourcesModel(Q_NULLPTR), m_noteRepository(noteRepository), - m_noteSourcesModel(Q_NULLPTR), m_tagQueries(tagQueries), m_tagRepository(tagRepository), m_errorHandler(Q_NULLPTR) { MetaTypes::registerAll(); } -QAbstractItemModel *ApplicationModel::noteSourcesModel() +QAbstractItemModel *ApplicationModel::dataSourcesModel() { - if (!m_noteSourcesModel) { - m_noteSourcesModel = new DataSourceListModel([this] { return noteSources(); }, this); + if (!m_dataSourcesModel) { + m_dataSourcesModel = new DataSourceListModel([this] { return dataSources(); }, this); } - return m_noteSourcesModel; + return m_dataSourcesModel; } -Domain::QueryResult::Ptr ApplicationModel::noteSources() +Domain::QueryResult::Ptr ApplicationModel::dataSources() { - if (!m_noteSources) { - m_noteSources = m_sourceQueries->findNotes(); + if (!m_dataSources) { + m_dataSources = createDataSourceQueryResult(); } - return m_noteSources; + return m_dataSources; } -Domain::DataSource::Ptr ApplicationModel::defaultNoteDataSource() +Domain::DataSource::Ptr ApplicationModel::defaultDataSource() { - QList sources = noteSources()->data(); + QList sources = dataSources()->data(); if (sources.isEmpty()) return Domain::DataSource::Ptr(); auto source = std::find_if(sources.begin(), sources.end(), [this] (const Domain::DataSource::Ptr &source) { - return m_noteRepository->isDefaultSource(source); - }); - - if (source != sources.end()) - return *source; - else - return sources.first(); -} - -QAbstractItemModel *ApplicationModel::taskSourcesModel() -{ - if (!m_taskSourcesModel) { - m_taskSourcesModel = new DataSourceListModel([this] { return taskSources(); }, this); - } - - return m_taskSourcesModel; -} - -Domain::QueryResult::Ptr ApplicationModel::taskSources() -{ - if (!m_taskSources) { - m_taskSources = m_sourceQueries->findTasks(); - } - - return m_taskSources; -} - -Domain::DataSource::Ptr ApplicationModel::defaultTaskDataSource() -{ - QList sources = taskSources()->data(); - - if (sources.isEmpty()) - return Domain::DataSource::Ptr(); - - auto source = std::find_if(sources.begin(), sources.end(), - [this] (const Domain::DataSource::Ptr &source) { - return m_taskRepository->isDefaultSource(source); + return isDefaultSource(source); }); if (source != sources.end()) @@ -203,16 +166,6 @@ emit currentPageChanged(page); } -void ApplicationModel::setDefaultNoteDataSource(Domain::DataSource::Ptr source) -{ - m_noteRepository->setDefaultSource(source); -} - -void ApplicationModel::setDefaultTaskDataSource(Domain::DataSource::Ptr source) -{ - m_taskRepository->setDefaultSource(source); -} - void ApplicationModel::setErrorHandler(ErrorHandler *errorHandler) { m_errorHandler = errorHandler; diff --git a/src/presentation/noteapplicationmodel.h b/src/presentation/noteapplicationmodel.h --- a/src/presentation/noteapplicationmodel.h +++ b/src/presentation/noteapplicationmodel.h @@ -49,7 +49,12 @@ const Domain::TagRepository::Ptr &tagRepository, QObject *parent = Q_NULLPTR); +public slots: + void setDefaultDataSource(const Domain::DataSource::Ptr &source) Q_DECL_OVERRIDE; + private: + Domain::QueryResult::Ptr createDataSourceQueryResult() Q_DECL_OVERRIDE; + bool isDefaultSource(const Domain::DataSource::Ptr &source) Q_DECL_OVERRIDE; AvailablePagesModelInterface *createAvailablePagesModel() Q_DECL_OVERRIDE; Domain::NoteQueries::Ptr m_noteQueries; diff --git a/src/presentation/noteapplicationmodel.cpp b/src/presentation/noteapplicationmodel.cpp --- a/src/presentation/noteapplicationmodel.cpp +++ b/src/presentation/noteapplicationmodel.cpp @@ -57,6 +57,21 @@ { } +void NoteApplicationModel::setDefaultDataSource(const Domain::DataSource::Ptr &source) +{ + m_noteRepository->setDefaultSource(source); +} + +Domain::QueryResult::Ptr NoteApplicationModel::createDataSourceQueryResult() +{ + return m_sourceQueries->findNotes(); +} + +bool NoteApplicationModel::isDefaultSource(const Domain::DataSource::Ptr &source) +{ + return m_noteRepository->isDefaultSource(source); +} + AvailablePagesModelInterface *NoteApplicationModel::createAvailablePagesModel() { return new AvailableNotePagesModel(m_noteQueries, diff --git a/src/presentation/taskapplicationmodel.h b/src/presentation/taskapplicationmodel.h --- a/src/presentation/taskapplicationmodel.h +++ b/src/presentation/taskapplicationmodel.h @@ -46,7 +46,12 @@ const Domain::TagRepository::Ptr &tagRepository, QObject *parent = Q_NULLPTR); +public slots: + void setDefaultDataSource(const Domain::DataSource::Ptr &source) Q_DECL_OVERRIDE; + private: + Domain::QueryResult::Ptr createDataSourceQueryResult() Q_DECL_OVERRIDE; + bool isDefaultSource(const Domain::DataSource::Ptr &source) Q_DECL_OVERRIDE; AvailablePagesModelInterface *createAvailablePagesModel() Q_DECL_OVERRIDE; }; diff --git a/src/presentation/taskapplicationmodel.cpp b/src/presentation/taskapplicationmodel.cpp --- a/src/presentation/taskapplicationmodel.cpp +++ b/src/presentation/taskapplicationmodel.cpp @@ -55,6 +55,21 @@ { } +void TaskApplicationModel::setDefaultDataSource(const Domain::DataSource::Ptr &source) +{ + m_taskRepository->setDefaultSource(source); +} + +Domain::QueryResult::Ptr TaskApplicationModel::createDataSourceQueryResult() +{ + return m_sourceQueries->findTasks(); +} + +bool TaskApplicationModel::isDefaultSource(const Domain::DataSource::Ptr &source) +{ + return m_taskRepository->isDefaultSource(source); +} + AvailablePagesModelInterface *TaskApplicationModel::createAvailablePagesModel() { return new AvailableTaskPagesModel(m_projectQueries, diff --git a/tests/features/cuke-steps.cpp b/tests/features/cuke-steps.cpp --- a/tests/features/cuke-steps.cpp +++ b/tests/features/cuke-steps.cpp @@ -135,8 +135,7 @@ auto appModel = Utils::DependencyManager::globalInstance().create(); // Since it is lazy loaded force ourselves in a known state - appModel->defaultNoteDataSource(); - appModel->defaultTaskDataSource(); + appModel->defaultDataSource(); appModel->setErrorHandler(&m_errorHandler); app = appModel; @@ -329,15 +328,9 @@ context->setModel(sourceListModel); } -GIVEN("^I display the available (\\S+) data sources$") { - REGEX_PARAM(QString, sourceType); - +GIVEN("^I display the flat data source list$") { ScenarioScope context; - auto propertyName = sourceType == "task" ? "taskSourcesModel" - : sourceType == "note" ? "noteSourcesModel" - : Q_NULLPTR; - - context->setModel(context->app->property(propertyName).value()); + context->setModel(context->app->property("dataSourcesModel").value()); context->waitForEmptyJobQueue(); } @@ -452,7 +445,7 @@ ScenarioScope context; - auto sourceList = context->app->property("taskSourcesModel").value(); + auto sourceList = context->app->property("dataSourcesModel").value(); VERIFY(sourceList); context->waitForStableState(); QModelIndex index = Zanshin::findIndex(sourceList, sourceName); @@ -701,14 +694,11 @@ config.writeEntry(keyName, id); } -WHEN("^the user changes the default (\\S+) data source to (.*)$") { - REGEX_PARAM(QString, sourceType); +WHEN("^the user changes the default data source to (.*)$") { REGEX_PARAM(QString, sourceName); ScenarioScope context; - auto sourcesModel = sourceType == "task" ? context->app->property("taskSourcesModel").value() - : sourceType == "note" ? context->app->property("noteSourcesModel").value() - : Q_NULLPTR; + auto sourcesModel = context->app->property("dataSourcesModel").value(); context->waitForStableState(); // I wish models had iterators... QList sources; @@ -720,11 +710,7 @@ return source->name() == sourceName; }); - - auto propertyName = sourceType == "task" ? "defaultTaskDataSource" - : sourceType == "note" ? "defaultNoteDataSource" - : Q_NULLPTR; - context->app->setProperty(propertyName, QVariant::fromValue(source)); + context->app->setProperty("defaultDataSource", QVariant::fromValue(source)); } @@ -834,16 +820,11 @@ COMPARE(context->editor->property(property), value); } -THEN("^the default (\\S+) data source is (.*)$") { - REGEX_PARAM(QString, sourceType); +THEN("^the default data source is (.*)$") { REGEX_PARAM(QString, expectedName); - auto propertyName = sourceType == "task" ? "defaultTaskDataSource" - : sourceType == "note" ? "defaultNoteDataSource" - : Q_NULLPTR; - ScenarioScope context; - auto source = context->app->property(propertyName).value(); + auto source = context->app->property("defaultDataSource").value(); VERIFY(!source.isNull()); COMPARE(source->name(), expectedName); } diff --git a/tests/features/renku/features/datasource/datasource-default-settings.feature b/tests/features/renku/features/datasource/datasource-default-settings.feature new file mode 100644 --- /dev/null +++ b/tests/features/renku/features/datasource/datasource-default-settings.feature @@ -0,0 +1,15 @@ +Feature: Default data source + As an advanced user + I can choose the default data source + In order to quickly store notes + + Scenario: Have a default data source for notes + Given I display the flat data source list + When the setting key defaultNoteCollection changes to 6 + Then the default data source is TestData/Private Notes + + Scenario: Change the default data source for notes + Given I display the flat data source list + And the setting key defaultNoteCollection changes to 42 + When the user changes the default data source to TestData/Private Notes + Then the setting key defaultNoteCollection is 6 diff --git a/tests/features/zanshin/features/datasource/datasource-listing.feature b/tests/features/renku/features/datasource/datasource-listing.feature copy from tests/features/zanshin/features/datasource/datasource-listing.feature copy to tests/features/renku/features/datasource/datasource-listing.feature --- a/tests/features/zanshin/features/datasource/datasource-listing.feature +++ b/tests/features/renku/features/datasource/datasource-listing.feature @@ -1,19 +1,10 @@ Feature: Data sources listing As an advanced user I can list sources - In order to list and store artifacts + In order to list and store notes - Scenario: Flat task data sources - Given I display the available task data sources - When I list the items - Then the list is: - | display | icon | - | TestData/Calendar1 | view-calendar-tasks | - | TestData/Calendar1/Calendar2 | view-calendar-tasks | - | TestData/Calendar1/Calendar2/Calendar3 | folder | - - Scenario: Flat note data sources - Given I display the available note data sources + Scenario: Flat data source list + Given I display the flat data source list When I list the items Then the list is: | display | icon | diff --git a/tests/features/zanshin/features/datasource/datasource-default-settings.feature b/tests/features/zanshin/features/datasource/datasource-default-settings.feature --- a/tests/features/zanshin/features/datasource/datasource-default-settings.feature +++ b/tests/features/zanshin/features/datasource/datasource-default-settings.feature @@ -1,26 +1,16 @@ -Feature: Data sources defaults +Feature: Default data source As an advanced user - I can choose the default data sources - In order to quickly store artifacts outside of projects + I can choose the default data source + In order to quickly store tasks Scenario: Have a default data source for tasks in the inbox - Given I display the available task data sources + Given I display the flat data source list When the setting key defaultCollection changes to 7 - Then the default task data source is TestData/Calendar1/Calendar2 + Then the default data source is TestData/Calendar1/Calendar2 Scenario: Change the default data source for tasks in the inbox - Given I display the available task data sources + Given I display the flat data source list And the setting key defaultCollection changes to 42 - When the user changes the default task data source to TestData/Calendar1/Calendar2 + When the user changes the default data source to TestData/Calendar1/Calendar2 Then the setting key defaultCollection is 7 - Scenario: Have a default data source for notes in the inbox - Given I display the available note data sources - When the setting key defaultNoteCollection changes to 6 - Then the default note data source is TestData/Private Notes - - Scenario: Change the default data source for notes in the inbox - Given I display the available note data sources - And the setting key defaultNoteCollection changes to 42 - When the user changes the default note data source to TestData/Private Notes - Then the setting key defaultNoteCollection is 6 diff --git a/tests/features/zanshin/features/datasource/datasource-listing.feature b/tests/features/zanshin/features/datasource/datasource-listing.feature --- a/tests/features/zanshin/features/datasource/datasource-listing.feature +++ b/tests/features/zanshin/features/datasource/datasource-listing.feature @@ -1,25 +1,17 @@ Feature: Data sources listing As an advanced user I can list sources - In order to list and store artifacts + In order to list and store tasks - Scenario: Flat task data sources - Given I display the available task data sources + Scenario: Flat data source list + Given I display the flat data source list When I list the items Then the list is: | display | icon | | TestData/Calendar1 | view-calendar-tasks | | TestData/Calendar1/Calendar2 | view-calendar-tasks | | TestData/Calendar1/Calendar2/Calendar3 | folder | - Scenario: Flat note data sources - Given I display the available note data sources - When I list the items - Then the list is: - | display | icon | - | TestData/Emails/Notes | folder | - | TestData/Private Notes | folder | - Scenario: All task and note sources appear in the list Given I display the available data sources When I list the items diff --git a/tests/units/presentation/applicationmodeltest.cpp b/tests/units/presentation/applicationmodeltest.cpp --- a/tests/units/presentation/applicationmodeltest.cpp +++ b/tests/units/presentation/applicationmodeltest.cpp @@ -101,7 +101,23 @@ { } +public slots: + void setDefaultDataSource(const Domain::DataSource::Ptr &) + { + } + private: + Domain::QueryResult::Ptr createDataSourceQueryResult() Q_DECL_OVERRIDE + { + auto provider = Domain::QueryResultProvider::Ptr::create(); + return Domain::QueryResult::create(provider); + } + + bool isDefaultSource(const Domain::DataSource::Ptr &) Q_DECL_OVERRIDE + { + return false; + } + Presentation::AvailablePagesModelInterface *createAvailablePagesModel() Q_DECL_OVERRIDE { return new FakeAvailablePagesModel(this); @@ -254,443 +270,6 @@ QVERIFY(qobject_cast(page)); } - void shouldProvideDataSourceModels() - { - // GIVEN - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto taskRepository = Domain::TaskRepository::Ptr(); - auto noteRepository = Domain::NoteRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepository, - noteRepository, - tagQueries, - tagRepository); - - // WHEN - auto tasks = app.taskSourcesModel(); - auto notes = app.noteSourcesModel(); - - // THEN - QVERIFY(qobject_cast(tasks)); - QVERIFY(qobject_cast(notes)); - } - - void shouldRetrieveDefaultTaskCollectionFromRepository() - { - // GIVEN - - // A data source - auto expectedSource = Domain::DataSource::Ptr::create(); - - // A source list containing the source we expect as default - auto provider = Domain::QueryResultProvider::Ptr::create(); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(expectedSource); - provider->append(Domain::DataSource::Ptr::create()); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); - - // Repository mock returning the data source as default - Utils::MockObject taskRepositoryMock; - foreach (const Domain::DataSource::Ptr &source, provider->data()) { - taskRepositoryMock(&Domain::TaskRepository::isDefaultSource).when(source).thenReturn(source == expectedSource); - } - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto noteRepository = Domain::NoteRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepositoryMock.getInstance(), - noteRepository, - tagQueries, - tagRepository); - - // WHEN - auto source = app.defaultTaskDataSource(); - - // THEN - QCOMPARE(source, expectedSource); - QVERIFY(taskRepositoryMock(&Domain::TaskRepository::isDefaultSource).when(expectedSource).exactly(1)); - } - - void shouldGiveFirstTaskCollectionAsDefaultIfNoneMatched() - { - // GIVEN - - // A list of irrelevant sources - auto provider = Domain::QueryResultProvider::Ptr::create(); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); - - // Repository mock returning the data source as default - Utils::MockObject taskRepositoryMock; - foreach (const Domain::DataSource::Ptr &source, provider->data()) { - taskRepositoryMock(&Domain::TaskRepository::isDefaultSource).when(source).thenReturn(false); - } - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto noteRepository = Domain::NoteRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepositoryMock.getInstance(), - noteRepository, - tagQueries, - tagRepository); - - // WHEN - auto source = app.defaultTaskDataSource(); - - // THEN - QCOMPARE(source, provider->data().first()); - } - - void shouldProvideNullPointerIfNoTaskSourceIsAvailable() - { - // GIVEN - - // An empty source list - auto provider = Domain::QueryResultProvider::Ptr::create(); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); - - // Repository mock returning the data source as default - Utils::MockObject taskRepositoryMock; - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto noteRepository = Domain::NoteRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepositoryMock.getInstance(), - noteRepository, - tagQueries, - tagRepository); - - // WHEN - auto source = app.defaultTaskDataSource(); - - // THEN - QVERIFY(source.isNull()); - } - - void shouldForwardDefaultTaskCollectionToRepository() - { - // GIVEN - - // A data source - auto source = Domain::DataSource::Ptr::create(); - - // A dummy source list - auto provider = Domain::QueryResultProvider::Ptr::create(); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); - - // Repository mock setting the default data source - Utils::MockObject taskRepositoryMock; - taskRepositoryMock(&Domain::TaskRepository::setDefaultSource).when(source).thenReturn(); - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto noteRepository = Domain::NoteRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepositoryMock.getInstance(), - noteRepository, - tagQueries, - tagRepository); - - - // WHEN - app.setDefaultTaskDataSource(source); - - // THEN - QVERIFY(taskRepositoryMock(&Domain::TaskRepository::setDefaultSource).when(source).exactly(1)); - } - - void shouldRetrieveDefaultNoteCollectionFromRepository() - { - // GIVEN - - // A data source - auto expectedSource = Domain::DataSource::Ptr::create(); - - // A source list containing the source we expect as default - auto provider = Domain::QueryResultProvider::Ptr::create(); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(expectedSource); - provider->append(Domain::DataSource::Ptr::create()); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); - - // Repository mock returning the data source as default - Utils::MockObject noteRepositoryMock; - foreach (const Domain::DataSource::Ptr &source, provider->data()) { - noteRepositoryMock(&Domain::NoteRepository::isDefaultSource).when(source).thenReturn(source == expectedSource); - } - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto taskRepository = Domain::TaskRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepository, - noteRepositoryMock.getInstance(), - tagQueries, - tagRepository); - - // WHEN - auto source = app.defaultNoteDataSource(); - - // THEN - QCOMPARE(source, expectedSource); - QVERIFY(noteRepositoryMock(&Domain::NoteRepository::isDefaultSource).when(expectedSource).exactly(1)); - } - - void shouldGiveFirstNoteCollectionAsDefaultIfNoneMatched() - { - // GIVEN - - // A list of irrelevant sources - auto provider = Domain::QueryResultProvider::Ptr::create(); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - provider->append(Domain::DataSource::Ptr::create()); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); - - // Repository mock returning the data source as default - Utils::MockObject noteRepositoryMock; - foreach (const Domain::DataSource::Ptr &source, provider->data()) { - noteRepositoryMock(&Domain::NoteRepository::isDefaultSource).when(source).thenReturn(false); - } - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto taskRepository = Domain::TaskRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepository, - noteRepositoryMock.getInstance(), - tagQueries, - tagRepository); - - // WHEN - auto source = app.defaultNoteDataSource(); - - // THEN - QCOMPARE(source, provider->data().first()); - } - - void shouldProvideNullPointerIfNoNoteSourceIsAvailable() - { - // GIVEN - - // An empty source list - auto provider = Domain::QueryResultProvider::Ptr::create(); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); - - // Repository mock returning the data source as default - Utils::MockObject noteRepositoryMock; - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto taskRepository = Domain::TaskRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepository, - noteRepositoryMock.getInstance(), - tagQueries, - tagRepository); - - // WHEN - auto source = app.defaultNoteDataSource(); - - // THEN - QVERIFY(source.isNull()); - } - - void shouldForwardDefaultNoteCollectionToRepository() - { - // GIVEN - - // A data source - auto source = Domain::DataSource::Ptr::create(); - - // A dummy source list - auto provider = Domain::QueryResultProvider::Ptr::create(); - auto sourceResult = Domain::QueryResult::create(provider); - - // Queries mock returning the list of data sources - Utils::MockObject sourceQueriesMock; - sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); - sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); - - // Repository mock setting the default data source - Utils::MockObject noteRepositoryMock; - noteRepositoryMock(&Domain::NoteRepository::setDefaultSource).when(source).thenReturn(); - - auto projectQueries = Domain::ProjectQueries::Ptr(); - auto projectRepository = Domain::ProjectRepository::Ptr(); - auto contextQueries = Domain::ContextQueries::Ptr(); - auto contextRepository = Domain::ContextRepository::Ptr(); - auto sourceRepository = Domain::DataSourceRepository::Ptr(); - auto taskQueries = Domain::TaskQueries::Ptr(); - auto taskRepository = Domain::TaskRepository::Ptr(); - auto tagQueries = Domain::TagQueries::Ptr(); - auto tagRepository = Domain::TagRepository::Ptr(); - ApplicationModel app(projectQueries, - projectRepository, - contextQueries, - contextRepository, - sourceQueriesMock.getInstance(), - sourceRepository, - taskQueries, - taskRepository, - noteRepositoryMock.getInstance(), - tagQueries, - tagRepository); - - // WHEN - app.setDefaultNoteDataSource(source); - - // THEN - QVERIFY(noteRepositoryMock(&Domain::NoteRepository::setDefaultSource).when(source).exactly(1)); - } - void shouldSetErrorHandlerToAllModels() { // GIVEN diff --git a/tests/units/presentation/noteapplicationmodeltest.cpp b/tests/units/presentation/noteapplicationmodeltest.cpp --- a/tests/units/presentation/noteapplicationmodeltest.cpp +++ b/tests/units/presentation/noteapplicationmodeltest.cpp @@ -23,7 +23,10 @@ #include +#include "utils/mockobject.h" + #include "presentation/availablenotepagesmodel.h" +#include "presentation/datasourcelistmodel.h" #include "presentation/noteapplicationmodel.h" class NoteApplicationModelTest : public QObject @@ -64,6 +67,259 @@ // THEN QVERIFY(qobject_cast(available)); } + + void shouldProvideDataSourceModel() + { + // GIVEN + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceQueries = Domain::DataSourceQueries::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto taskRepository = Domain::TaskRepository::Ptr(); + auto noteQueries = Domain::NoteQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::NoteApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepository, + noteQueries, + noteRepository, + tagQueries, + tagRepository); + + // WHEN + auto notes = app.dataSourcesModel(); + + // THEN + QVERIFY(qobject_cast(notes)); + } + + void shouldRetrieveDefaultNoteCollectionFromRepository() + { + // GIVEN + + // A data source + auto expectedSource = Domain::DataSource::Ptr::create(); + + // A source list containing the source we expect as default + auto provider = Domain::QueryResultProvider::Ptr::create(); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(expectedSource); + provider->append(Domain::DataSource::Ptr::create()); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); + + // Repository mock returning the data source as default + Utils::MockObject noteRepositoryMock; + foreach (const Domain::DataSource::Ptr &source, provider->data()) { + noteRepositoryMock(&Domain::NoteRepository::isDefaultSource).when(source).thenReturn(source == expectedSource); + } + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceQueries = Domain::DataSourceQueries::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto taskRepository = Domain::TaskRepository::Ptr(); + auto noteQueries = Domain::NoteQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::NoteApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepository, + noteQueries, + noteRepositoryMock.getInstance(), + tagQueries, + tagRepository); + + // WHEN + auto source = app.defaultDataSource(); + + // THEN + QCOMPARE(source, expectedSource); + QVERIFY(noteRepositoryMock(&Domain::NoteRepository::isDefaultSource).when(expectedSource).exactly(1)); + } + + void shouldGiveFirstNoteCollectionAsDefaultIfNoneMatched() + { + // GIVEN + + // A list of irrelevant sources + auto provider = Domain::QueryResultProvider::Ptr::create(); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); + + // Repository mock returning the data source as default + Utils::MockObject noteRepositoryMock; + foreach (const Domain::DataSource::Ptr &source, provider->data()) { + noteRepositoryMock(&Domain::NoteRepository::isDefaultSource).when(source).thenReturn(false); + } + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceQueries = Domain::DataSourceQueries::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto taskRepository = Domain::TaskRepository::Ptr(); + auto noteQueries = Domain::NoteQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::NoteApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepository, + noteQueries, + noteRepositoryMock.getInstance(), + tagQueries, + tagRepository); + + // WHEN + auto source = app.defaultDataSource(); + + // THEN + QCOMPARE(source, provider->data().first()); + } + + void shouldProvideNullPointerIfNoNoteSourceIsAvailable() + { + // GIVEN + + // An empty source list + auto provider = Domain::QueryResultProvider::Ptr::create(); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); + + // Repository mock returning the data source as default + Utils::MockObject noteRepositoryMock; + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceQueries = Domain::DataSourceQueries::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto taskRepository = Domain::TaskRepository::Ptr(); + auto noteQueries = Domain::NoteQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::NoteApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepository, + noteQueries, + noteRepositoryMock.getInstance(), + tagQueries, + tagRepository); + + // WHEN + auto source = app.defaultDataSource(); + + // THEN + QVERIFY(source.isNull()); + } + + void shouldForwardDefaultNoteCollectionToRepository() + { + // GIVEN + + // A data source + auto source = Domain::DataSource::Ptr::create(); + + // A dummy source list + auto provider = Domain::QueryResultProvider::Ptr::create(); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(sourceResult); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); + + // Repository mock setting the default data source + Utils::MockObject noteRepositoryMock; + noteRepositoryMock(&Domain::NoteRepository::setDefaultSource).when(source).thenReturn(); + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceQueries = Domain::DataSourceQueries::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto taskRepository = Domain::TaskRepository::Ptr(); + auto noteQueries = Domain::NoteQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::NoteApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepository, + noteQueries, + noteRepositoryMock.getInstance(), + tagQueries, + tagRepository); + + // WHEN + app.setDefaultDataSource(source); + + // THEN + QVERIFY(noteRepositoryMock(&Domain::NoteRepository::setDefaultSource).when(source).exactly(1)); + } }; QTEST_MAIN(NoteApplicationModelTest) diff --git a/tests/units/presentation/taskapplicationmodeltest.cpp b/tests/units/presentation/taskapplicationmodeltest.cpp --- a/tests/units/presentation/taskapplicationmodeltest.cpp +++ b/tests/units/presentation/taskapplicationmodeltest.cpp @@ -23,7 +23,10 @@ #include +#include "utils/mockobject.h" + #include "presentation/availabletaskpagesmodel.h" +#include "presentation/datasourcelistmodel.h" #include "presentation/taskapplicationmodel.h" class TaskApplicationModelTest : public QObject @@ -62,6 +65,241 @@ // THEN QVERIFY(qobject_cast(available)); } + + void shouldProvideDataSourceModels() + { + // GIVEN + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(Domain::QueryResult::Ptr()); + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto taskRepository = Domain::TaskRepository::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::TaskApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepository, + noteRepository, + tagQueries, + tagRepository); + + // WHEN + auto tasks = app.dataSourcesModel(); + + // THEN + QVERIFY(qobject_cast(tasks)); + } + + void shouldRetrieveDefaultTaskCollectionFromRepository() + { + // GIVEN + + // A data source + auto expectedSource = Domain::DataSource::Ptr::create(); + + // A source list containing the source we expect as default + auto provider = Domain::QueryResultProvider::Ptr::create(); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(expectedSource); + provider->append(Domain::DataSource::Ptr::create()); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); + + // Repository mock returning the data source as default + Utils::MockObject taskRepositoryMock; + foreach (const Domain::DataSource::Ptr &source, provider->data()) { + taskRepositoryMock(&Domain::TaskRepository::isDefaultSource).when(source).thenReturn(source == expectedSource); + } + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::TaskApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepositoryMock.getInstance(), + noteRepository, + tagQueries, + tagRepository); + + // WHEN + auto source = app.defaultDataSource(); + + // THEN + QCOMPARE(source, expectedSource); + QVERIFY(taskRepositoryMock(&Domain::TaskRepository::isDefaultSource).when(expectedSource).exactly(1)); + } + + void shouldGiveFirstTaskCollectionAsDefaultIfNoneMatched() + { + // GIVEN + + // A list of irrelevant sources + auto provider = Domain::QueryResultProvider::Ptr::create(); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + provider->append(Domain::DataSource::Ptr::create()); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); + + // Repository mock returning the data source as default + Utils::MockObject taskRepositoryMock; + foreach (const Domain::DataSource::Ptr &source, provider->data()) { + taskRepositoryMock(&Domain::TaskRepository::isDefaultSource).when(source).thenReturn(false); + } + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::TaskApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepositoryMock.getInstance(), + noteRepository, + tagQueries, + tagRepository); + + // WHEN + auto source = app.defaultDataSource(); + + // THEN + QCOMPARE(source, provider->data().first()); + } + + void shouldProvideNullPointerIfNoTaskSourceIsAvailable() + { + // GIVEN + + // An empty source list + auto provider = Domain::QueryResultProvider::Ptr::create(); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); + + // Repository mock returning the data source as default + Utils::MockObject taskRepositoryMock; + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::TaskApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepositoryMock.getInstance(), + noteRepository, + tagQueries, + tagRepository); + + // WHEN + auto source = app.defaultDataSource(); + + // THEN + QVERIFY(source.isNull()); + } + + void shouldForwardDefaultTaskCollectionToRepository() + { + // GIVEN + + // A data source + auto source = Domain::DataSource::Ptr::create(); + + // A dummy source list + auto provider = Domain::QueryResultProvider::Ptr::create(); + auto sourceResult = Domain::QueryResult::create(provider); + + // Queries mock returning the list of data sources + Utils::MockObject sourceQueriesMock; + sourceQueriesMock(&Domain::DataSourceQueries::findNotes).when().thenReturn(Domain::QueryResult::Ptr()); + sourceQueriesMock(&Domain::DataSourceQueries::findTasks).when().thenReturn(sourceResult); + + // Repository mock setting the default data source + Utils::MockObject taskRepositoryMock; + taskRepositoryMock(&Domain::TaskRepository::setDefaultSource).when(source).thenReturn(); + + auto projectQueries = Domain::ProjectQueries::Ptr(); + auto projectRepository = Domain::ProjectRepository::Ptr(); + auto contextQueries = Domain::ContextQueries::Ptr(); + auto contextRepository = Domain::ContextRepository::Ptr(); + auto sourceRepository = Domain::DataSourceRepository::Ptr(); + auto taskQueries = Domain::TaskQueries::Ptr(); + auto noteRepository = Domain::NoteRepository::Ptr(); + auto tagQueries = Domain::TagQueries::Ptr(); + auto tagRepository = Domain::TagRepository::Ptr(); + Presentation::TaskApplicationModel app(projectQueries, + projectRepository, + contextQueries, + contextRepository, + sourceQueriesMock.getInstance(), + sourceRepository, + taskQueries, + taskRepositoryMock.getInstance(), + noteRepository, + tagQueries, + tagRepository); + + + // WHEN + app.setDefaultDataSource(source); + + // THEN + QVERIFY(taskRepositoryMock(&Domain::TaskRepository::setDefaultSource).when(source).exactly(1)); + } }; QTEST_MAIN(TaskApplicationModelTest)