void MetadataIOCoordinator::afterImportHandler(const QVector<Models::ArtworkMetadata*> &itemsToRead, bool ignoreBackups) {
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
const QHash<QString, ImportDataResult> &importResult = m_ReadingWorker->getImportResult();
const QVector<QPair<int, int> > &rangesToUpdate = m_ReadingWorker->getRangesToUpdate();
if (!ignoreBackups && settingsModel->getSaveBackups()) {
LOG_DEBUG << "Restoring the backups...";
int size = itemsToRead.size();
for (int i = 0; i < size; ++i) {
Models::ArtworkMetadata *metadata = itemsToRead.at(i);
const QString &filepath = metadata->getFilepath();
if (importResult.contains(filepath)) {
const ImportDataResult &importResultItem = importResult.value(filepath);
MetadataSavingCopy copy(importResultItem.BackupDict);
copy.saveToMetadata(metadata);
}
}
} else {
LOG_DEBUG << "Skipped restoring the backups";
}
if (!getHasErrors()) {
m_CommandManager->addToLibrary(itemsToRead);
}
m_CommandManager->updateArtworks(rangesToUpdate);
m_CommandManager->submitForSpellCheck(itemsToRead);
m_CommandManager->submitForWarningsCheck(itemsToRead);
}
void MetadataIOCoordinator::readingFinishedHandler(bool ignoreBackups) {
Q_ASSERT(m_CanProcessResults);
m_CanProcessResults = false;
const QHash<QString, ImportDataResult> &importResult = m_ReadingWorker->getImportResult();
const QVector<Models::ArtworkMetadata*> &itemsToRead = m_ReadingWorker->getArtworksToImport();
qDebug() << "Setting imported metadata...";
int size = itemsToRead.size();
for (int i = 0; i < size; ++i) {
Models::ArtworkMetadata *metadata = itemsToRead.at(i);
const QString &filepath = metadata->getFilepath();
if (importResult.contains(filepath)) {
const ImportDataResult &importResultItem = importResult.value(filepath);
metadata->initialize(importResultItem.Title,
importResultItem.Description,
importResultItem.Keywords);
metadata->setSize(importResultItem.Size);
}
}
afterImportHandler(itemsToRead, ignoreBackups);
qDebug() << "Metadata import finished";
emit metadataReadingFinished();
}
void FilteredModelTests::filterDescriptionTest() {
DECLARE_MODELS_AND_GENERATE(10);
Models::SettingsModel settingsModel;
settingsModel.setSearchUsingAnd(false);
commandManagerMock.InjectDependency(&settingsModel);
for (int i = 0; i < 10; ++i) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
if (i % 2) {
metadata->initialize("title", "description", QStringList() << "keyword1" << "keyword2");
} else {
metadata->initialize("", "", QStringList());
}
}
filteredItemsModel.setSearchTerm("desc");
QCOMPARE(filteredItemsModel.getItemsCount(), 5);
filteredItemsModel.setSearchTerm("!desc");
QCOMPARE(filteredItemsModel.getItemsCount(), 0);
filteredItemsModel.setSearchTerm("description");
QCOMPARE(filteredItemsModel.getItemsCount(), 5);
// strict match does not work for description/title
filteredItemsModel.setSearchTerm("!description");
QCOMPARE(filteredItemsModel.getItemsCount(), 0);
}
void FilteredModelTests::filterTitleAndKeywordsTest() {
DECLARE_MODELS_AND_GENERATE(10);
Models::SettingsModel settingsModel;
settingsModel.setSearchUsingAnd(false);
commandManagerMock.InjectDependency(&settingsModel);
for (int i = 0; i < 10; ++i) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
if (i % 2 == 0) {
metadata->initialize("title", "description", QStringList() << "keyword1" << "mess1");
} else {
metadata->initialize("title", "description", QStringList() << "keyword2" << "mess2");
}
}
filteredItemsModel.setSearchTerm("keyword1 tit");
QCOMPARE(filteredItemsModel.getItemsCount(), 10);
filteredItemsModel.setSearchTerm("!keyword tit");
QCOMPARE(filteredItemsModel.getItemsCount(), 10);
settingsModel.setSearchUsingAnd(true);
filteredItemsModel.setSearchTerm("!keyword tit");
QCOMPARE(filteredItemsModel.getItemsCount(), 0);
filteredItemsModel.setSearchTerm("!keyword2 title");
QCOMPARE(filteredItemsModel.getItemsCount(), 5);
}
void MetadataIOCoordinator::readingFinishedHandler(bool ignoreBackups) {
Q_ASSERT(m_CanProcessResults);
m_CanProcessResults = false;
const QHash<QString, ImportDataResult> &importResult = m_ReadingWorker->getImportResult();
const QVector<Models::ArtworkMetadata*> &itemsToRead = m_ReadingWorker->getItemsToRead();
LOG_DEBUG << "Setting imported metadata...";
int size = itemsToRead.size();
for (int i = 0; i < size; ++i) {
Models::ArtworkMetadata *metadata = itemsToRead.at(i);
const QString &filepath = metadata->getFilepath();
if (importResult.contains(filepath)) {
const ImportDataResult &importResultItem = importResult.value(filepath);
metadata->initialize(importResultItem.Title,
importResultItem.Description,
importResultItem.Keywords);
Models::ImageArtwork *image = dynamic_cast<Models::ImageArtwork*>(metadata);
if (image != NULL) {
image->setImageSize(importResultItem.ImageSize);
image->setDateTimeOriginal(importResultItem.DateTimeOriginal);
}
metadata->setFileSize(importResultItem.FileSize);
}
}
afterImportHandler(itemsToRead, ignoreBackups);
LOG_DEBUG << "Metadata import finished";
emit metadataReadingFinished();
}
void Exiv2ReadingWorker::process() {
LOG_DEBUG << "Worker #" << m_WorkerIndex << "started";
bool anyError = false;
int size = m_ItemsToRead.size();
for (int i = 0; i < size; ++i) {
if (m_Stopped) { break; }
Models::ArtworkMetadata *artwork = m_ItemsToRead.at(i);
const QString &filepath = artwork->getFilepath();
ImportDataResult importResult;
try {
if (readMetadata(artwork, importResult)) {
Q_ASSERT(!m_ImportResult.contains(filepath));
m_ImportResult.insert(filepath, importResult);
}
}
catch(Exiv2::Error &error) {
anyError = true;
LOG_WARNING << "Worker" << m_WorkerIndex << "Exiv2 error:" << error.what();
}
catch(...) {
anyError = true;
LOG_WARNING << "Worker" << m_WorkerIndex << "Reading error for item" << filepath;
}
}
LOG_INFO << "Worker #" << m_WorkerIndex << "finished";
emit finished(anyError);
}
void FilteredModelTests::clearEmptyKeywordsTest() {
DECLARE_MODELS_AND_GENERATE(1);
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(0);
metadata->clearKeywords();
commandManagerMock.resetAnyCommandProcessed();
filteredItemsModel.clearKeywords(0);
QVERIFY(!commandManagerMock.anyCommandProcessed());
}
void FilteredModelTests::removeMetadataMarksAsModifiedTest() {
DECLARE_MODELS_AND_GENERATE(1);
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(0);
QVERIFY(!metadata->isModified());
metadata->setIsSelected(true);
filteredItemsModel.removeMetadataInSelected();
QVERIFY(metadata->isModified());
}
void Commands::CommandManager::submitForSpellCheck(const QVector<Models::ArtworkMetadata *> &items) const {
if ((m_SettingsModel != NULL) &&
m_SettingsModel->getUseSpellCheck() &&
(m_SpellCheckerService != NULL) &&
!items.isEmpty()) {
QVector<Common::BasicKeywordsModel *> itemsToSubmit;
int count = items.length();
itemsToSubmit.reserve(count);
for (int i = 0; i < count; ++i) {
Models::ArtworkMetadata *metadata = items.at(i);
itemsToSubmit << metadata->getBasicModel();
}
this->submitForSpellCheck(itemsToSubmit);
}
}
void ReplaceTests::caseSensitiveTest() {
const int itemsToGenerate = 10;
DECLARE_MODELS_AND_GENERATE(itemsToGenerate);
QString replaceFrom = "rePLace";
QString replaceTo = "Replaced";
QString initString = "ReplaceMe";
QString finalString = "ReplacedMe";
auto flags = Common::SearchFlags::Description |
Common::SearchFlags::Title |
Common::SearchFlags::Keywords;
for (int i = 0; i < itemsToGenerate; i++) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
metadata->initialize(initString, initString, QStringList() << initString);
}
auto artWorksInfo = filteredItemsModel.getSearchablePreviewOriginalItems(replaceFrom, flags);
std::shared_ptr<Commands::FindAndReplaceCommand> replaceCommand(
new Commands::FindAndReplaceCommand(artWorksInfo, replaceFrom, replaceTo, flags));
auto result = commandManagerMock.processCommand(replaceCommand);
for (int i = 0; i < itemsToGenerate; i++) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
QCOMPARE(metadata->getDescription(), finalString);
QCOMPARE(metadata->getTitle(), finalString);
QCOMPARE(metadata->getKeywords()[0], finalString);
QVERIFY(metadata->isModified());
}
}
void FilteredModelTests::setSelectedForZippingTest() {
DECLARE_MODELS_AND_GENERATE(10);
Models::ZipArchiver zipArchiver;
commandManagerMock.InjectDependency(&zipArchiver);
for (int i = 0; i < 10; ++i) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
metadata->initialize("title", "description", QStringList() << "keyword1" << "keyword2");
if (i % 2) {
metadata->setIsSelected(true);
}
}
filteredItemsModel.setSelectedForZipping();
const QVector<Models::ArtworkMetadata*> &artworks = zipArchiver.getArtworkList();
QCOMPARE(artworks.length(), 5);
}
void FilteredModelTests::removeMetadataDeletesMetadataTest() {
DECLARE_MODELS_AND_GENERATE(10);
for (int i = 0; i < 10; ++i) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
metadata->initialize("title", "description", QStringList() << "keyword1" << "keyword2");
metadata->setIsSelected(true);
}
filteredItemsModel.removeMetadataInSelected();
for (int i = 0; i < 10; ++i) {
Mocks::ArtworkMetadataMock *metadata = artItemsModelMock.getMockArtwork(i);
QVERIFY(metadata->isDescriptionEmpty());
QVERIFY(metadata->isTitleEmpty());
QVERIFY(metadata->areKeywordsEmpty());
QVERIFY(metadata->isModified());
}
}
std::shared_ptr<Commands::ICommandResult> Commands::PasteKeywordsCommand::execute(const ICommandManager *commandManagerInterface) const {
LOG_INFO << "Pasting" << m_KeywordsList.length() << "keywords to" << m_MetadataElements.size() << "item(s)";
CommandManager *commandManager = (CommandManager*)commandManagerInterface;
QVector<int> indicesToUpdate;
std::vector<UndoRedo::ArtworkMetadataBackup> artworksBackups;
QVector<Models::ArtworkMetadata*> itemsToSave;
size_t size = m_MetadataElements.size();
indicesToUpdate.reserve((int)size);
artworksBackups.reserve(size);
itemsToSave.reserve((int)size);
for (size_t i = 0; i < size; ++i) {
const Models::MetadataElement &element = m_MetadataElements.at(i);
Models::ArtworkMetadata *metadata = element.getOrigin();
indicesToUpdate.append(element.getOriginalIndex());
artworksBackups.emplace_back(metadata);
metadata->appendKeywords(m_KeywordsList);
itemsToSave.append(metadata);
}
if (size > 0) {
commandManager->submitForSpellCheck(itemsToSave);
commandManager->submitForWarningsCheck(itemsToSave);
commandManager->saveArtworksBackups(itemsToSave);
std::unique_ptr<UndoRedo::IHistoryItem> modifyArtworksItem(new UndoRedo::ModifyArtworksHistoryItem(artworksBackups, indicesToUpdate,
UndoRedo::PasteModificationType));
commandManager->recordHistoryItem(modifyArtworksItem);
} else {
LOG_WARNING << "Pasted zero real words!";
}
std::shared_ptr<PasteKeywordsCommandResult> result(new PasteKeywordsCommandResult(indicesToUpdate));
return result;
}
bool WarningsModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const {
Q_UNUSED(sourceParent);
QAbstractItemModel *sourceItemModel = sourceModel();
Models::ArtItemsModel *artItemsModel = dynamic_cast<Models::ArtItemsModel *>(sourceItemModel);
Q_ASSERT(artItemsModel != NULL);
Models::ArtworkMetadata *metadata = artItemsModel->getArtwork(sourceRow);
bool rowIsOk = false;
if (metadata != NULL) {
Common::WarningFlags warningsFlags = metadata->getWarningsFlags();
bool anyWarnings = warningsFlags != Common::WarningFlags::None;
rowIsOk = anyWarnings;
if (m_ShowOnlySelected) {
rowIsOk = metadata->isSelected() && anyWarnings;
}
}
return rowIsOk;
}
void MetadataIOCoordinator::continueWithoutReading() {
LOG_DEBUG << "Setting technical data";
const QHash<QString, ImportDataResult> &importResult = m_ReadingWorker->getImportResult();
const QVector<Models::ArtworkMetadata*> &itemsToRead = m_ReadingWorker->getItemsToRead();
int size = itemsToRead.size();
for (int i = 0; i < size; ++i) {
Models::ArtworkMetadata *metadata = itemsToRead.at(i);
const QString &filepath = metadata->getFilepath();
if (importResult.contains(filepath)) {
const ImportDataResult &importResultItem = importResult.value(filepath);
Models::ImageArtwork *image = dynamic_cast<Models::ImageArtwork*>(metadata);
if (image != NULL) {
image->setImageSize(importResultItem.ImageSize);
image->setDateTimeOriginal(importResultItem.DateTimeOriginal);
}
metadata->setFileSize(importResultItem.FileSize);
}
}
}
void ReplaceTests::replaceKeywordsTest() {
const int itemsToGenerate = 10;
DECLARE_MODELS_AND_GENERATE(itemsToGenerate);
QString replaceFrom = "keywordOld";
QString replaceTo = "keywordNew";
QString replaceToLower = replaceTo.toLower();
auto flags = Common::SearchFlags::CaseSensitive |
Common::SearchFlags::Description |
Common::SearchFlags::Title |
Common::SearchFlags::Keywords;
for (int i = 0; i < itemsToGenerate; i++) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
metadata->initialize(QString("title"), QString("description"),
QStringList() << replaceToLower << "dummyKey" << replaceFrom);
}
auto artWorksInfo = filteredItemsModel.getSearchablePreviewOriginalItems(replaceFrom, flags);
std::shared_ptr<Commands::FindAndReplaceCommand> replaceCommand(
new Commands::FindAndReplaceCommand(artWorksInfo, replaceFrom, replaceTo, flags));
auto result = commandManagerMock.processCommand(replaceCommand);
for (int i = 0; i < itemsToGenerate; i++) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
QCOMPARE(metadata->getDescription(), QString("description"));
QCOMPARE(metadata->getTitle(), QString("title"));
QStringList test = metadata->getKeywords();
QStringList gold;
gold << replaceToLower << "dummyKey";
qSort(gold.begin(), gold.end());
qSort(test.begin(), test.end());
QCOMPARE(gold, test);
QVERIFY(metadata->isModified());
}
}
int SpellingProducesWarningsTest::doTest() {
Models::ArtItemsModel *artItemsModel = m_CommandManager->getArtItemsModel();
QList<QUrl> files;
files << getImagePathForTest("images-for-tests/vector/026.jpg");
int addedCount = artItemsModel->addLocalArtworks(files);
VERIFY(addedCount == files.length(), "Failed to add file");
MetadataIO::MetadataIOCoordinator *ioCoordinator = m_CommandManager->getMetadataIOCoordinator();
SignalWaiter waiter;
QObject::connect(ioCoordinator, SIGNAL(metadataReadingFinished()), &waiter, SIGNAL(finished()));
ioCoordinator->continueReading(true);
if (!waiter.wait(20)) {
VERIFY(false, "Timeout exceeded for reading metadata.");
}
VERIFY(!ioCoordinator->getHasErrors(), "Errors in IO Coordinator while reading");
Models::ArtworkMetadata *metadata = artItemsModel->getArtwork(0);
sleepWait(3, [metadata]() {
return !Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInTitle) &&
!Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInDescription) &&
!Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInKeywords);
});
VERIFY(!Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInTitle), "Error for reading title");
VERIFY(!Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInDescription), "Error for reading description");
VERIFY(!Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInKeywords), "Error for reading keywords");
QString wrongWord = "abbreviatioe";
metadata->setDescription(metadata->getDescription() + ' ' + wrongWord);
metadata->setTitle(metadata->getTitle() + ' ' + wrongWord);
metadata->appendKeyword("correct part " + wrongWord);
metadata->setIsSelected(true);
Models::FilteredArtItemsProxyModel *filteredModel = m_CommandManager->getFilteredArtItemsModel();
SpellCheck::SpellCheckerService *spellCheckService = m_CommandManager->getSpellCheckerService();
SignalWaiter spellingWaiter;
QObject::connect(spellCheckService, SIGNAL(spellCheckQueueIsEmpty()), &spellingWaiter, SIGNAL(finished()));
filteredModel->spellCheckSelected();
if (!spellingWaiter.wait(5)) {
VERIFY(false, "Timeout for waiting for first spellcheck results");
}
LOG_INFO << "Spellchecking finished. Waiting for warnings...";
sleepWait(5, [=]() {
return Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInTitle) &&
Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInDescription) &&
Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInKeywords);
});
auto *keywordsModel = metadata->getBasicModel();
VERIFY(keywordsModel->hasDescriptionSpellError(), "Description spell error not detected");
VERIFY(keywordsModel->hasTitleSpellError(), "Title spell error not detected");
VERIFY(keywordsModel->hasKeywordsSpellError(), "Keywords spell error not detected");
VERIFY(Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInTitle),
"Warning was not produced for title spelling error");
VERIFY(Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInDescription),
"Warning was not produced for description spelling error");
VERIFY(Common::HasFlag(metadata->getWarningsFlags(), Common::WarningFlags::SpellErrorsInKeywords),
"Warning was not produced for keywords spelling error");
return 0;
}
int AddToUserDictionaryTest::doTest() {
Models::ArtItemsModel *artItemsModel = m_CommandManager->getArtItemsModel();
QList<QUrl> files;
files << getImagePathForTest("images-for-tests/pixmap/seagull.jpg");
int addedCount = artItemsModel->addLocalArtworks(files);
VERIFY(addedCount == files.length(), "Failed to add file");
MetadataIO::MetadataIOCoordinator *ioCoordinator = m_CommandManager->getMetadataIOCoordinator();
SignalWaiter waiter;
QObject::connect(ioCoordinator, SIGNAL(metadataReadingFinished()), &waiter, SIGNAL(finished()));
ioCoordinator->continueReading(true);
if (!waiter.wait(20)) {
VERIFY(false, "Timeout exceeded for reading metadata.");
}
VERIFY(!ioCoordinator->getHasErrors(), "Errors in IO Coordinator while reading");
Models::ArtworkMetadata *metadata = artItemsModel->getArtwork(0);
// wait for after-add spellchecking
QThread::sleep(1);
auto *basicKeywordsModel = metadata->getBasicModel();
QString wrongWord = "abbreviatioe";
metadata->setDescription(metadata->getDescription() + ' ' + wrongWord);
metadata->setTitle(metadata->getTitle() + ' ' + wrongWord);
metadata->appendKeyword("correct part " + wrongWord);
metadata->setIsSelected(true);
Models::FilteredArtItemsProxyModel *filteredModel = m_CommandManager->getFilteredArtItemsModel();
SpellCheck::SpellCheckerService *spellCheckService = m_CommandManager->getSpellCheckerService();
QObject::connect(spellCheckService, SIGNAL(spellCheckQueueIsEmpty()), &waiter, SIGNAL(finished()));
filteredModel->spellCheckSelected();
if (!waiter.wait(5)) {
VERIFY(false, "Timeout for waiting for spellcheck results");
}
// wait for finding suggestions
QThread::sleep(1);
VERIFY(basicKeywordsModel->hasDescriptionSpellError(), "Description spell error not detected");
VERIFY(basicKeywordsModel->hasTitleSpellError(), "Title spell error not detected");
VERIFY(basicKeywordsModel->hasKeywordsSpellError(), "Keywords spell error not detected");
spellCheckService->addWordToUserDictionary(wrongWord);
SignalWaiter spellingWaiter;
QObject::connect(spellCheckService, SIGNAL(spellCheckQueueIsEmpty()), &spellingWaiter, SIGNAL(finished()));
QCoreApplication::processEvents(QEventLoop::AllEvents);
// wait add user word to finish
if (!spellingWaiter.wait(5)) {
VERIFY(false, "Timeout for waiting for spellcheck results");
}
sleepWait(5, [=]() {
return !basicKeywordsModel->hasDescriptionSpellError() &&
!basicKeywordsModel->hasTitleSpellError() &&
!basicKeywordsModel->hasKeywordsSpellError();
});
int userDictWords = spellCheckService->getUserDictWordsNumber();
LOG_DEBUG << "User dict words count:" << userDictWords;
VERIFY(userDictWords == 1, "Wrong number of words in user dictionary");
VERIFY(!basicKeywordsModel->hasDescriptionSpellError(), "After adding word. Description spell error is still present");
VERIFY(!basicKeywordsModel->hasTitleSpellError(), "After adding word. Title spell error is still present");
VERIFY(!basicKeywordsModel->hasKeywordsSpellError(), "After adding word. Keywords spell error is still present");
return 0;
}
int SpellCheckUndoTest::doTest() {
Models::ArtItemsModel *artItemsModel = m_CommandManager->getArtItemsModel();
QList<QUrl> files;
files << getImagePathForTest("images-for-tests/vector/026.jpg");
int addedCount = artItemsModel->addLocalArtworks(files);
VERIFY(addedCount == files.length(), "Failed to add file");
MetadataIO::MetadataIOCoordinator *ioCoordinator = m_CommandManager->getMetadataIOCoordinator();
SignalWaiter waiter;
QObject::connect(ioCoordinator, SIGNAL(metadataReadingFinished()), &waiter, SIGNAL(finished()));
ioCoordinator->continueReading(true);
if (!waiter.wait(20)) {
VERIFY(false, "Timeout exceeded for reading metadata.");
}
VERIFY(!ioCoordinator->getHasErrors(), "Errors in IO Coordinator while reading");
Models::ArtworkMetadata *metadata = artItemsModel->getArtwork(0);
QString wrongWord = "abbreviatioe";
metadata->setDescription(metadata->getDescription() + ' ' + wrongWord);
metadata->setTitle(metadata->getTitle() + ' ' + wrongWord);
metadata->appendKeyword("correct part " + wrongWord);
metadata->setIsSelected(true);
// wait for after-add spellchecking
QThread::sleep(1);
Models::FilteredArtItemsProxyModel *filteredModel = m_CommandManager->getFilteredArtItemsModel();
SpellCheck::SpellCheckerService *spellCheckService = m_CommandManager->getSpellCheckerService();
QObject::connect(spellCheckService, SIGNAL(spellCheckQueueIsEmpty()), &waiter, SIGNAL(finished()));
filteredModel->spellCheckSelected();
if (!waiter.wait(5)) {
VERIFY(false, "Timeout for waiting for first spellcheck results");
}
// wait for finding suggestions
QThread::sleep(1);
Common::BasicKeywordsModel *basicKeywordsModel = metadata->getKeywordsModel();
VERIFY(basicKeywordsModel->hasDescriptionSpellError(), "Description spell error not detected");
VERIFY(basicKeywordsModel->hasTitleSpellError(), "Title spell error not detected");
VERIFY(basicKeywordsModel->hasKeywordsSpellError(), "Keywords spell error not detected");
filteredModel->clearKeywords(0);
QThread::sleep(1);
VERIFY(!basicKeywordsModel->hasKeywordsSpellError(), "Keywords spell error not cleared");
UndoRedo::UndoRedoManager *undoRedoManager = m_CommandManager->getUndoRedoManager();
undoRedoManager->undoLastAction();
if (!waiter.wait(5)) {
VERIFY(false, "Timeout for waiting for second spellcheck results");
}
// wait for finding suggestions
QThread::sleep(1);
VERIFY(basicKeywordsModel->hasDescriptionSpellError(), "Description spell error not detected on the second time");
VERIFY(basicKeywordsModel->hasTitleSpellError(), "Title spell error not detected on the second time");
VERIFY(basicKeywordsModel->hasKeywordsSpellError(), "Keywords spell error not detected on the second time");
return 0;
}
int ClearMetadataTest::doTest() {
Models::ArtItemsModel *artItemsModel = m_CommandManager->getArtItemsModel();
QList<QUrl> files;
files << getImagePathForTest("images-for-tests/pixmap/seagull-for-clear.jpg");
int addedCount = artItemsModel->addLocalArtworks(files);
VERIFY(addedCount == files.length(), "Failed to add file");
MetadataIO::MetadataIOCoordinator *ioCoordinator = m_CommandManager->getMetadataIOCoordinator();
SignalWaiter waiter;
QObject::connect(ioCoordinator, SIGNAL(metadataReadingFinished()), &waiter, SIGNAL(finished()));
ioCoordinator->continueReading(true);
if (!waiter.wait(20)) {
VERIFY(false, "Timeout exceeded for reading metadata.");
}
VERIFY(!ioCoordinator->getHasErrors(), "Errors in IO Coordinator while reading");
Models::ArtworkMetadata *metadata = artItemsModel->getArtwork(0);
const QStringList &keywords = metadata->getKeywords();
QStringList expectedKeywords = QString("picture,seagull,bird").split(',');
VERIFY(expectedKeywords == keywords, "Keywords are not the same!");
VERIFY(metadata->getDescription() == "Seagull description", "Description is not the same!");
VERIFY(metadata->getTitle() == "Seagull title", "Title is not the same!");
Models::FilteredArtItemsProxyModel *filteredModel = m_CommandManager->getFilteredArtItemsModel();
metadata->setIsSelected(true);
filteredModel->removeMetadataInSelected();
bool doOverwrite = true, dontSaveBackups = false;
QObject::connect(ioCoordinator, SIGNAL(metadataWritingFinished()), &waiter, SIGNAL(finished()));
artItemsModel->saveSelectedArtworks(QVector<int>() << 0, doOverwrite, dontSaveBackups);
if (!waiter.wait(20)) {
VERIFY(false, "Timeout exceeded for writing metadata.");
}
VERIFY(!ioCoordinator->getHasErrors(), "Errors in IO Coordinator while writing");
filteredModel->removeSelectedArtworks();
addedCount = artItemsModel->addLocalArtworks(files);
VERIFY(addedCount == files.length(), "Failed to add file after removal");
ioCoordinator->continueReading(true);
if (!waiter.wait(20)) {
VERIFY(false, "Timeout exceeded for reading metadata.");
}
VERIFY(!ioCoordinator->getHasErrors(), "Errors in IO Coordinator while reading");
metadata = artItemsModel->getArtwork(0);
VERIFY(metadata->getBasicModel()->isDescriptionEmpty(), "Description was not empty");
VERIFY(metadata->getBasicModel()->isTitleEmpty(), "Title was not empty");
VERIFY(metadata->getBasicModel()->areKeywordsEmpty(), "Keywords were not empty");
return 0;
}