File indexing completed on 2024-04-21 15:03:01

 /*
     SPDX-FileCopyrightText: 2017 David Edmundson <davidedmundson@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "runnermanager.h"
 
 #ifdef KSERVICE_BUILD_DEPRECATED_SINCE
 #if KRUNNER_BUILD_DEPRECATED_SINCE(5, 72) && KSERVICE_BUILD_DEPRECATED_SINCE(5, 0)
 #define WITH_KSERVICE 1
 #endif
 #endif
 
 #ifndef WITH_KSERVICE
 #define WITH_KSERVICE 0
 #endif
 
 #include <QAction>
 #include <QObject>
 #include <QProcess>
 #include <QSignalSpy>
 #include <QStandardPaths>
 #include <QTest>
 #include <QTime>
 #include <QTimer>
 
 #if WITH_KSERVICE
 #include <KSycoca>
 #endif
 
 #include "abstractrunnertest.h"
 #include "kpluginmetadata_utils_p.h"
 
 using namespace Plasma;
 
 Q_DECLARE_METATYPE(Plasma::QueryMatch)
 Q_DECLARE_METATYPE(QList<Plasma::QueryMatch>)
 
 class DBusRunnerTest : public AbstractRunnerTest
 {
     Q_OBJECT
 public:
     DBusRunnerTest();
     ~DBusRunnerTest() override;
 
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
     void testMatch();
     void testMulti();
     void testFilterProperties();
     void testFilterProperties_data();
     void testRequestActionsOnce();
     void testDBusRunnerSyntaxIntegration();
     void testIconData();
     void testLifecycleMethods();
     void testRequestActionsOnceWildcards();
 #if WITH_KSERVICE
     void testMulti_data();
 #endif
 };
 
 DBusRunnerTest::DBusRunnerTest()
     : AbstractRunnerTest()
 {
     qRegisterMetaType<QList<Plasma::QueryMatch>>();
 }
 
 DBusRunnerTest::~DBusRunnerTest()
 {
 }
 
 void DBusRunnerTest::initTestCase()
 {
     // Set up a layer in the bin dir so ksycoca & KPluginMetaData find the Plasma/Runner service type
     const QByteArray defaultDataDirs = qEnvironmentVariableIsSet("XDG_DATA_DIRS") ? qgetenv("XDG_DATA_DIRS") : QByteArray("/usr/local:/usr");
     const QByteArray modifiedDataDirs = QFile::encodeName(QCoreApplication::applicationDirPath()) + QByteArrayLiteral("/data:") + defaultDataDirs;
     qputenv("XDG_DATA_DIRS", modifiedDataDirs);
 
     QStandardPaths::setTestModeEnabled(true);
 }
 
 void DBusRunnerTest::cleanup()
 {
     // Make sure kill the running processes after each test
     killRunningDBusProcesses();
 }
 
 void DBusRunnerTest::testMatch()
 {
     QProcess *process = startDBusRunnerProcess({QStringLiteral("net.krunnertests.dave")});
     initProperties();
     launchQuery(QStringLiteral("foo"));
 
     // verify matches
     const QList<QueryMatch> matches = manager->matches();
     QCOMPARE(matches.count(), 1);
     auto result = matches.first();
 
     // see testremoterunner.cpp
     QCOMPARE(result.id(), QStringLiteral("dbusrunnertest_id1")); // note the runner name is prepended
     QCOMPARE(result.text(), QStringLiteral("Match 1"));
     QCOMPARE(result.iconName(), QStringLiteral("icon1"));
     QCOMPARE(result.type(), Plasma::QueryMatch::ExactMatch);
     QCOMPARE(result.isMultiLine(), true);
     // relevance can't be compared easily because RunnerContext meddles with it
 
     // verify actions
     QTRY_COMPARE_WITH_TIMEOUT(manager->actionsForMatch(result).count(), 1, 10000);
     auto action = manager->actionsForMatch(result).constFirst();
 
     QCOMPARE(action->text(), QStringLiteral("Action 1"));
 
     QSignalSpy processSpy(process, &QProcess::readyRead);
     manager->run(result);
     processSpy.wait();
     QCOMPARE(process->readAllStandardOutput().trimmed().split('\n').constLast(), QByteArray("Running:id1:"));
 
     result.setSelectedAction(action);
     manager->run(result);
     processSpy.wait();
     QCOMPARE(process->readAllStandardOutput().trimmed().split('\n').constLast(), QByteArray("Running:id1:action1"));
 }
 
 #if WITH_KSERVICE
 void DBusRunnerTest::testMulti_data()
 {
     QTest::addColumn<bool>("useKService");
 
     QTest::newRow("deprecated") << true;
     QTest::newRow("non-deprecated") << false;
 }
 #endif
 
 void DBusRunnerTest::testMulti()
 {
 #if WITH_KSERVICE
     QFETCH(bool, useKService);
 #endif
     startDBusRunnerProcess({QStringLiteral("net.krunnertests.multi.a1")}, QStringLiteral("net.krunnertests.multi.a1"));
     startDBusRunnerProcess({QStringLiteral("net.krunnertests.multi.a2")}, QStringLiteral("net.krunnertests.multi.a2"));
     manager.reset(new RunnerManager()); // This case is special, because we want to load the runners manually
 
 #if WITH_KSERVICE
     if (useKService) {
         KService::Ptr s(new KService(QFINDTESTDATA("dbusrunnertestmulti.desktop")));
         QVERIFY(s);
         manager->loadRunner(s);
     } else {
 #endif
         auto md = parseMetaDataFromDesktopFile(QFINDTESTDATA("dbusrunnertestmulti.desktop"));
         QVERIFY(md.isValid());
         manager->loadRunner(md);
 #if WITH_KSERVICE
     }
 #endif
     launchQuery(QStringLiteral("foo"));
 
     // verify matches, must be one from each
     const QList<QueryMatch> matches = manager->matches();
     QCOMPARE(matches.count(), 2);
 
     const QString first = matches.at(0).data().toList().constFirst().toString();
     const QString second = matches.at(1).data().toList().constFirst().toString();
     QVERIFY(first != second);
     QVERIFY(first == QLatin1String("net.krunnertests.multi.a1") || first == QStringLiteral("net.krunnertests.multi.a2"));
     QVERIFY(second == QLatin1String("net.krunnertests.multi.a1") || second == QStringLiteral("net.krunnertests.multi.a2"));
 }
 
 void DBusRunnerTest::testRequestActionsOnce()
 {
     startDBusRunnerProcess({QStringLiteral("net.krunnertests.dave")});
     initProperties();
 
     // Construct a fake match with necessary data
     QueryMatch fakeMatch(runner);
     fakeMatch.setId(QStringLiteral("dbusrunnertest_id1"));
     fakeMatch.setData(QVariantList({QStringLiteral("net.krunnertests.dave"), QStringList({QStringLiteral("action1"), QStringLiteral("action2")})}));
 
     // The actions should not be fetched before we have set up the match session
     QCOMPARE(manager->actionsForMatch(fakeMatch).count(), 0);
     launchQuery(QStringLiteral("foo"));
     // We need to retry this, because the DBus call to fetch the actions is async
     QTRY_COMPARE_WITH_TIMEOUT(manager->actionsForMatch(fakeMatch).count(), 2, 2500);
 }
 
 void DBusRunnerTest::testFilterProperties_data()
 {
     QTest::addColumn<QString>("rejectedQuery");
     QTest::addColumn<QString>("acceptedQuery");
 
     QTest::newRow("min-letter-count") << "fo"
                                       << "foo";
     QTest::newRow("match-regex") << "barfoo"
                                  << "foobar";
 }
 
 void DBusRunnerTest::testFilterProperties()
 {
     QFETCH(QString, rejectedQuery);
     QFETCH(QString, acceptedQuery);
     QProcess *process = startDBusRunnerProcess({QStringLiteral("net.krunnertests.dave")});
     initProperties();
 
     launchQuery(rejectedQuery);
     // Match method was not called, because of the min letter count or match regex property
     QVERIFY(process->readAllStandardOutput().isEmpty());
     // accepted query fits those constraints
     launchQuery(acceptedQuery);
     QCOMPARE(process->readAllStandardOutput().trimmed(), QString(QStringLiteral("Matching:") + acceptedQuery).toLocal8Bit());
 }
 
 void DBusRunnerTest::testDBusRunnerSyntaxIntegration()
 {
     startDBusRunnerProcess({QStringLiteral("net.krunnertests.dave")});
     initProperties();
     const QList<RunnerSyntax> syntaxes = runner->syntaxes();
     QCOMPARE(syntaxes.size(), 2);
 
     QCOMPARE(syntaxes.at(0).exampleQueries().size(), 1);
     QCOMPARE(syntaxes.at(0).exampleQueries().constFirst(), QStringLiteral("syntax1"));
     QCOMPARE(syntaxes.at(0).description(), QStringLiteral("description1"));
     QCOMPARE(syntaxes.at(1).exampleQueries().size(), 1);
     QCOMPARE(syntaxes.at(1).exampleQueries().constFirst(), QStringLiteral("syntax2"));
     QCOMPARE(syntaxes.at(1).description(), QStringLiteral("description2"));
 }
 
 void DBusRunnerTest::testIconData()
 {
     startDBusRunnerProcess({QStringLiteral("net.krunnertests.dave")});
     initProperties();
 
     launchQuery(QStringLiteral("fooCostomIcon"));
 
     const auto matches = manager->matches();
     QCOMPARE(matches.count(), 1);
     auto result = matches.first();
 
     QImage expectedIcon(10, 10, QImage::Format_RGBA8888);
     expectedIcon.fill(Qt::blue);
 
     QCOMPARE(result.icon().availableSizes().first(), QSize(10, 10));
     QCOMPARE(result.icon().pixmap(QSize(10, 10)), QPixmap::fromImage(expectedIcon));
 }
 
 void DBusRunnerTest::testLifecycleMethods()
 {
     QProcess *process = startDBusRunnerProcess({QStringLiteral("net.krunnertests.dave"), QString()});
     manager.reset(new RunnerManager()); // This case is special, because we want to load the runners manually
     auto md = parseMetaDataFromDesktopFile(QFINDTESTDATA("dbusrunnertestruntimeconfig.desktop"));
     manager->loadRunner(md);
     QCOMPARE(manager->runners().count(), 1);
     // Match session should be set up automatically
     launchQuery(QStringLiteral("fooo"));
 
     // Make sure we got our match, end the match session and give the process a bit of time to get the DBus signal
     QTRY_COMPARE_WITH_TIMEOUT(manager->matches().count(), 1, 2000);
     manager->matchSessionComplete();
     QTest::qWait(500);
 
     const QStringList lifeCycleSteps = QString::fromLocal8Bit(process->readAllStandardOutput()).split(QLatin1Char('\n'), Qt::SkipEmptyParts);
     const QStringList expectedLifeCycleSteps = {
         QStringLiteral("Config"),
         QStringLiteral("Matching:fooo"),
         QStringLiteral("Teardown"),
     };
     QCOMPARE(lifeCycleSteps, expectedLifeCycleSteps);
 
     // The query does not match our min letter count we set at runtime
     launchQuery(QStringLiteral("foo"));
     QVERIFY(manager->matches().isEmpty());
     // The query does not match our match regex we set at runtime
     launchQuery(QStringLiteral("barfoo"));
     QVERIFY(manager->matches().isEmpty());
 }
 
 void DBusRunnerTest::testRequestActionsOnceWildcards()
 {
     initProperties();
     manager.reset(new RunnerManager()); // This case is special, because we want to load the runners manually
     auto md = parseMetaDataFromDesktopFile(QFINDTESTDATA("dbusrunnertestmulti.desktop"));
     QVERIFY(md.isValid());
     manager->loadRunner(md);
     QCOMPARE(manager->runners().count(), 1);
     launchQuery("foo");
     QVERIFY(manager->matches().isEmpty());
     QueryMatch match(manager->runners().constFirst());
     match.setId("test");
     match.setData(QStringList{"net.krunnertests.multi.a1"});
     QVERIFY(manager->actionsForMatch(match).isEmpty());
     manager->matchSessionComplete();
 
     // We have started the process later and the actions should now be fetched when the match session is started
     startDBusRunnerProcess({QStringLiteral("net.krunnertests.multi.a1")}, QStringLiteral("net.krunnertests.multi.a1"));
     QTest::qWait(500); // Wait a bit for the runner to pick up the new service
 
     launchQuery("fooo");
     QVERIFY(!manager->matches().isEmpty());
     QVERIFY(!manager->actionsForMatch(match).isEmpty());
 }
 
 QTEST_MAIN(DBusRunnerTest)
 
 #include "dbusrunnertest.moc"