{

Q_OBJECT

FolderManTestHelper helper;

static QVariantMap

shortcutCapabilities(const bool userStatusEnabled, const bool assistantEnabled, const QString &assistantVersion = QStringLiteral("1.0.9"))

{

return {

{QStringLiteral("user_status"), QVariantMap{{QStringLiteral("enabled"), userStatusEnabled}}},

{QStringLiteral("assistant"),

QVariantMap{

{QStringLiteral("enabled"), assistantEnabled},

{QStringLiteral("version"), assistantVersion},

}},

};

}

static QPushButton *shortcutButton(const AccountSettings &settings, const char *objectName)

{

return settings.findChild<QPushButton *>(QString::fromLatin1(objectName));

}

/** @brief Creates an account backed by the test network access manager. */

static AccountPtr accountWithFakeNetworkAccessManager()

{

auto *const fakeNetworkAccessManager = new FakeQNAM({});

fakeNetworkAccessManager->setOverride(

[fakeNetworkAccessManager](QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice *) {

return new FakePayloadReply(operation,

request,

QByteArrayLiteral(R"({"ocs":{"meta":{"status":"ok","statuscode":200,"message":"OK"},"data":{}}})"),

fakeNetworkAccessManager);

});

auto account = Account::create();

account->setUrl(QUrl(QStringLiteral("https://example.invalid")));

account->setCredentials(new FakeCredentials{fakeNetworkAccessManager});

return account;

}

private Q_SLOTS:

void initTestCase()

{

OCC::Logger::instance()->setLogFlush(true);

OCC::Logger::instance()->setLogDebug(true);

QStandardPaths::setTestModeEnabled(true);

}

void test_whenAccountStateIsNotConnected_doesNotCrash()

{

auto account = Account::create();

auto accountState = new FakeAccountState(account);

accountState->setStateForTesting(OCC::AccountState::SignedOut);

QCOMPARE_EQ(accountState->state(), OCC::AccountState::SignedOut);

AccountSettings a(accountState);

}

void test_whenAccountStateIsConnected_doesNotCrash()

{

// this occurred because ConnectionValidator used to set the account

// inside a Account's _e2e member, instead of letting Account itself

// do that.

auto account = Account::create();

auto accountState = new FakeAccountState(account);

QCOMPARE_EQ(accountState->state(), OCC::AccountState::Connected);

AccountSettings a(accountState);

}

void test_accountSectionsFollowExpectedOrder()

{

auto account = Account::create();

auto accountState = FakeAccountState(account);

AccountSettings settings(&accountState);

const auto layout = settings.findChild<QVBoxLayout *>(QStringLiteral("verticalLayout_2"));

const auto shortcutsPanel = settings.findChild<QWidget *>(QStringLiteral("accountShortcutsPanel"));

const auto syncFoldersPanel = settings.findChild<QWidget *>(QStringLiteral("syncFoldersPanel"));

const auto fileProviderPanel = settings.findChild<QWidget *>(QStringLiteral("fileProviderMaintenancePanel"));

const auto encryptionPanel = settings.findChild<QWidget *>(QStringLiteral("encryptionPanel"));

const auto connectionPanel = settings.findChild<QWidget *>(QStringLiteral("accountStatusPanel"));

const auto accountActionsPanel = settings.findChild<QWidget *>(QStringLiteral("accountActionsPanel"));

QVERIFY(layout);

QVERIFY(shortcutsPanel);

QVERIFY(syncFoldersPanel);

QVERIFY(fileProviderPanel);

QVERIFY(qobject_cast<QFrame *>(fileProviderPanel));

QVERIFY(encryptionPanel);

QVERIFY(connectionPanel);

QVERIFY(accountActionsPanel);

QVERIFY(layout->indexOf(shortcutsPanel) < layout->indexOf(syncFoldersPanel));

QVERIFY(layout->indexOf(syncFoldersPanel) < layout->indexOf(fileProviderPanel));

QVERIFY(layout->indexOf(fileProviderPanel) < layout->indexOf(encryptionPanel));

QVERIFY(layout->indexOf(encryptionPanel) < layout->indexOf(connectionPanel));

QVERIFY(layout->indexOf(connectionPanel) < layout->indexOf(accountActionsPanel));

QCOMPARE(fileProviderPanel->layout()->contentsMargins(), shortcutsPanel->layout()->contentsMargins());

}

void test_accountShortcutsFollowConnectionState()

{

auto account = accountWithFakeNetworkAccessManager();

account->setCapabilities(shortcutCapabilities(true, true));

auto accountState = FakeAccountState(account);

AccountSettings settings(&accountState);

const auto activitiesButton = shortcutButton(settings, "activitiesShortcutButton");

const auto userStatusButton = shortcutButton(settings, "userStatusShortcutButton");

const auto assistantButton = shortcutButton(settings, "assistantShortcutButton");

const auto searchButton = shortcutButton(settings, "searchShortcutButton");

QVERIFY(activitiesButton);

QVERIFY(userStatusButton);

QVERIFY(assistantButton);

QVERIFY(searchButton);

QVERIFY(!activitiesButton->isHidden());

QVERIFY(!userStatusButton->isHidden());

QVERIFY(!assistantButton->isHidden());

QVERIFY(!searchButton->isHidden());

accountState.setStateForTesting(AccountState::SignedOut);

QVERIFY(activitiesButton->isHidden());

QVERIFY(userStatusButton->isHidden());

QVERIFY(assistantButton->isHidden());

QVERIFY(searchButton->isHidden());

accountState.setStateForTesting(AccountState::Connected);

QVERIFY(!activitiesButton->isHidden());

QVERIFY(!userStatusButton->isHidden());

QVERIFY(!assistantButton->isHidden());

QVERIFY(!searchButton->isHidden());

}

void test_accountShortcutLabelsMatchDedicatedWindows()

{

auto account = Account::create();

auto accountState = FakeAccountState(account);

AccountSettings settings(&accountState);

QCOMPARE(shortcutButton(settings, "activitiesShortcutButton")->text(), QCoreApplication::translate("ActivitiesWindow", "Activities"));

QCOMPARE(shortcutButton(settings, "userStatusShortcutButton")->text(), QCoreApplication::translate("UserStatusWindow", "Online status"));

QCOMPARE(shortcutButton(settings, "assistantShortcutButton")->text(), QCoreApplication::translate("AssistantWindow", "Assistant"));

QCOMPARE(shortcutButton(settings, "searchShortcutButton")->text(), QCoreApplication::translate("SearchWindow", "Search"));

}

void test_assistantShortcutIconUsesLightPaletteForeground()

{

auto account = accountWithFakeNetworkAccessManager();

account->setCapabilities(shortcutCapabilities(true, true));

auto accountState = FakeAccountState(account);

auto parent = QWidget{};

auto lightPalette = parent.palette();

lightPalette.setColor(QPalette::Base, Qt::white);

parent.setPalette(lightPalette);

AccountSettings settings(&accountState, &parent);

const auto assistantButton = shortcutButton(settings, "assistantShortcutButton");

QVERIFY(assistantButton);

const auto iconImage = assistantButton->icon().pixmap(QSize(24, 24)).toImage();

QVERIFY(!iconImage.isNull());

auto foregroundPixel = QColor{};

for (auto y = 0; y < iconImage.height(); ++y) {

for (auto x = 0; x < iconImage.width(); ++x) {

const auto pixel = iconImage.pixelColor(x, y);

if (pixel.alpha() > foregroundPixel.alpha()) {

foregroundPixel = pixel;

}

}

}

QVERIFY(foregroundPixel.alpha() > 0);

QVERIFY(Theme::isDarkColor(foregroundPixel));

}

void test_accountShortcutsFollowLiveCapabilities()

{

auto account = accountWithFakeNetworkAccessManager();

auto accountState = FakeAccountState(account);

AccountSettings settings(&accountState);

const auto activitiesButton = shortcutButton(settings, "activitiesShortcutButton");

const auto userStatusButton = shortcutButton(settings, "userStatusShortcutButton");

const auto assistantButton = shortcutButton(settings, "assistantShortcutButton");

const auto searchButton = shortcutButton(settings, "searchShortcutButton");

QVERIFY(activitiesButton);

QVERIFY(userStatusButton);

QVERIFY(assistantButton);

QVERIFY(searchButton);

QVERIFY(!activitiesButton->isHidden());

QVERIFY(userStatusButton->isHidden());

QVERIFY(assistantButton->isHidden());

QVERIFY(!searchButton->isHidden());

account->setCapabilities(shortcutCapabilities(true, true, QStringLiteral("1.0.8")));

QVERIFY(!userStatusButton->isHidden());

QVERIFY(assistantButton->isHidden());

account->setCapabilities(shortcutCapabilities(true, true));

QVERIFY(!userStatusButton->isHidden());

QVERIFY(!assistantButton->isHidden());

account->setCapabilities(shortcutCapabilities(false, false));

QVERIFY(userStatusButton->isHidden());

QVERIFY(assistantButton->isHidden());

}

void test_accountShortcutButtonsEmitAccountSpecificRequests()

{

auto account = accountWithFakeNetworkAccessManager();

account->setCapabilities(shortcutCapabilities(true, true));

auto accountState = FakeAccountState(account);

AccountSettings settings(&accountState);

AccountState *activitiesAccount = nullptr;

AccountState *userStatusAccount = nullptr;

AccountState *assistantAccount = nullptr;

AccountState *searchAccount = nullptr;

connect(&settings, &AccountSettings::showIssuesList, this, [&activitiesAccount](AccountState *requestedAccount) {

activitiesAccount = requestedAccount;

});

connect(&settings, &AccountSettings::showUserStatus, this, [&userStatusAccount](AccountState *requestedAccount) {

userStatusAccount = requestedAccount;

});

connect(&settings, &AccountSettings::showAssistant, this, [&assistantAccount](AccountState *requestedAccount) {

assistantAccount = requestedAccount;

});

connect(&settings, &AccountSettings::showSearch, this, [&searchAccount](AccountState *requestedAccount) {

searchAccount = requestedAccount;

});

shortcutButton(settings, "activitiesShortcutButton")->click();

shortcutButton(settings, "userStatusShortcutButton")->click();

shortcutButton(settings, "assistantShortcutButton")->click();

shortcutButton(settings, "searchShortcutButton")->click();

QCOMPARE(activitiesAccount, &accountState);

QCOMPARE(userStatusAccount, &accountState);

QCOMPARE(assistantAccount, &accountState);

QCOMPARE(searchAccount, &accountState);

}

void test_mnemonicDialog_wrapsLongMnemonic()

{

auto account = Account::create();

auto accountState = new FakeAccountState(account);

accountState->setStateForTesting(AccountState::SignedOut);

AccountSettings accountSettings(accountState);

const auto mnemonic = QStringLiteral(

"squirrel purchase favorite document remember solution "

"language discover umbrella tomorrow exercise mountain");

auto dialogFound = false;

auto textEditFound = false;

auto readOnly = false;

auto displayedMnemonic = QString{};

auto lineWrapMode = QTextEdit::NoWrap;

auto horizontalScrollBarPolicy = Qt::ScrollBarAsNeeded;

auto initialDialogWidth = 0;

auto resizedDialogWidth = 0;

auto initialTextEditWidth = 0;

auto resizedTextEditWidth = 0;

auto visualLineCount = 0;

QMetaObject::invokeMethod(this, [&] {

const auto dialog = qobject_cast<QDialog *>(QApplication::activeModalWidget());

if (!dialog) {

QApplication::closeAllWindows();

return;

}

dialogFound = true;

initialDialogWidth = dialog->width();

const auto mnemonicTextEdit = dialog->findChild<QTextEdit *>(QStringLiteral("mnemonicTextEdit"));

if (mnemonicTextEdit) {

textEditFound = true;

initialTextEditWidth = mnemonicTextEdit->width();

}

dialog->resize(initialDialogWidth / 2, dialog->height());

QMetaObject::invokeMethod(dialog, [&, dialog, mnemonicTextEdit] {

resizedDialogWidth = dialog->width();

if (mnemonicTextEdit) {

resizedTextEditWidth = mnemonicTextEdit->width();

readOnly = mnemonicTextEdit->isReadOnly();

displayedMnemonic = mnemonicTextEdit->toPlainText();

lineWrapMode = mnemonicTextEdit->lineWrapMode();

horizontalScrollBarPolicy = mnemonicTextEdit->horizontalScrollBarPolicy();

const auto textLayout = mnemonicTextEdit->document()->firstBlock().layout();

if (textLayout) {

visualLineCount = textLayout->lineCount();

}

}

dialog->accept();

}, Qt::QueuedConnection);

}, Qt::QueuedConnection);

const auto invoked = QMetaObject::invokeMethod(&accountSettings, "displayMnemonic", Qt::DirectConnection, Q_ARG(QString, mnemonic));

QVERIFY(invoked);

QVERIFY(dialogFound);

QVERIFY(textEditFound);

QVERIFY(readOnly);

QCOMPARE(displayedMnemonic, mnemonic);

QCOMPARE(lineWrapMode, QTextEdit::WidgetWidth);

QCOMPARE(horizontalScrollBarPolicy, Qt::ScrollBarAlwaysOff);

QVERIFY(resizedDialogWidth < initialDialogWidth);

QVERIFY(resizedTextEditWidth < initialTextEditWidth);

QVERIFY(visualLineCount > 1);

}