243 lines
9.7 KiB
C++
243 lines
9.7 KiB
C++
/**
|
|
* Copyright 2015 Holger Kaelberer <holger.k@elberer.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License or (at your option) version 3 or any later version
|
|
* accepted by the membership of KDE e.V. (or its successor approved
|
|
* by the membership of KDE e.V.), which shall act as a proxy
|
|
* defined in Section 14 of version 3 of the license.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <QSocketNotifier>
|
|
#include <QApplication>
|
|
#include <QNetworkAccessManager>
|
|
#include <QTest>
|
|
#include <QTemporaryFile>
|
|
#include <QStandardPaths>
|
|
|
|
#include "core/daemon.h"
|
|
#include "core/device.h"
|
|
#include "core/kdeconnectplugin.h"
|
|
#include "kdeconnect-version.h"
|
|
#include "plugins/notifications/notificationsplugin.h"
|
|
#include "plugins/notifications/notificationslistener.h"
|
|
#include "plugins/notifications/notificationsdbusinterface.h"
|
|
#include "plugins/notifications/notifyingapplication.h"
|
|
|
|
// Tweaked NotificationsPlugin for testing
|
|
class TestNotificationsPlugin : public NotificationsPlugin
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit TestNotificationsPlugin(QObject *parent, const QVariantList &args)
|
|
: NotificationsPlugin(parent, args)
|
|
{
|
|
}
|
|
|
|
virtual ~TestNotificationsPlugin() {};
|
|
|
|
// allow to access notificationsListener for testing:
|
|
NotificationsListener* getNotificationsListener() const
|
|
{
|
|
return notificationsListener;
|
|
}
|
|
|
|
void setNotificationsListener(NotificationsListener* value)
|
|
{
|
|
notificationsListener = value;
|
|
}
|
|
|
|
NotificationsDbusInterface* getNotificationsDbusInterface() const
|
|
{
|
|
return notificationsDbusInterface;
|
|
}
|
|
};
|
|
|
|
// Tweaked NotificationsListener for testing:
|
|
class TestedNotificationsListener: public NotificationsListener
|
|
{
|
|
|
|
public:
|
|
explicit TestedNotificationsListener(KdeConnectPlugin* aPlugin,
|
|
NotificationsDbusInterface* aDbusInterface)
|
|
: NotificationsListener(aPlugin, aDbusInterface)
|
|
{}
|
|
|
|
virtual ~TestedNotificationsListener()
|
|
{}
|
|
|
|
QHash<QString, NotifyingApplication>& getApplications()
|
|
{
|
|
return applications;
|
|
}
|
|
|
|
void setApplications(const QHash<QString, NotifyingApplication>& value)
|
|
{
|
|
applications = value;
|
|
}
|
|
|
|
};
|
|
|
|
class TestNotificationListener : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
TestNotificationListener()
|
|
: plugin(nullptr)
|
|
{
|
|
QStandardPaths::setTestModeEnabled(true);
|
|
}
|
|
|
|
private Q_SLOTS:
|
|
void testNotify();
|
|
|
|
private:
|
|
TestNotificationsPlugin* plugin;
|
|
};
|
|
|
|
void TestNotificationListener::testNotify()
|
|
{
|
|
//
|
|
// set things up:
|
|
//
|
|
|
|
QString dId("testid");
|
|
Device *d = new Device(nullptr, dId); // not setting any parent or we will double free the dbusInterface
|
|
plugin = new TestNotificationsPlugin(this,
|
|
QVariantList({ QVariant::fromValue<Device*>(d),
|
|
"notifications_plugin",
|
|
{"kdeconnect.notification"}}));
|
|
QVERIFY(plugin->getNotificationsListener());
|
|
delete plugin->getNotificationsListener();
|
|
|
|
// inject our tweaked NotificationsListener:
|
|
TestedNotificationsListener* listener = new TestedNotificationsListener(plugin, plugin->getNotificationsDbusInterface());
|
|
QVERIFY(listener);
|
|
plugin->setNotificationsListener(listener);
|
|
QCOMPARE(listener, plugin->getNotificationsListener());
|
|
|
|
// make sure config is default:
|
|
plugin->config()->set("generalPersistent", false);
|
|
plugin->config()->set("generalIncludeBody", true);
|
|
plugin->config()->set("generalUrgency", 0);
|
|
QCOMPARE(plugin->config()->get<bool>("generalPersistent"), false);
|
|
QCOMPARE(plugin->config()->get<bool>("generalIncludeBody"), true);
|
|
QCOMPARE(plugin->config()->get<bool>("generalUrgency"), false);
|
|
|
|
// applications are modified directly:
|
|
listener->getApplications().clear();
|
|
QCOMPARE(listener->getApplications().count(), 0);
|
|
|
|
//
|
|
// Go !!!
|
|
//
|
|
|
|
uint replacesId = 99;
|
|
uint retId;
|
|
|
|
// regular Notify call that is synchronized ...
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{}}, 0);
|
|
// ... should return replacesId,
|
|
QCOMPARE(retId, replacesId);
|
|
// ... and create a new application internally that is initialized correctly:
|
|
QCOMPARE(listener->getApplications().count(), 1);
|
|
QVERIFY(listener->getApplications().contains("testApp"));
|
|
QVERIFY(listener->getApplications()["testApp"].active);
|
|
QCOMPARE(listener->getApplications()["testApp"].name, QStringLiteral("testApp"));
|
|
QVERIFY(listener->getApplications()["testApp"].blacklistExpression.pattern().isEmpty());
|
|
QCOMPARE(listener->getApplications()["testApp"].name, QStringLiteral("testApp"));
|
|
QCOMPARE(listener->getApplications()["testApp"].icon, QStringLiteral("some-icon"));
|
|
|
|
// another one, with other timeout and urgency values:
|
|
retId = listener->Notify("testApp2", replacesId+1, "some-icon2", "summary2", "body2", {}, {{"urgency", 2}}, 10);
|
|
QCOMPARE(retId, replacesId+1);
|
|
QCOMPARE(listener->getApplications().count(), 2);
|
|
QVERIFY(listener->getApplications().contains("testApp2"));
|
|
QVERIFY(listener->getApplications().contains("testApp"));
|
|
|
|
// if persistent-only is set, timeouts > 0 are not synced:
|
|
plugin->config()->set("generalPersistent", true);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{}}, 1);
|
|
QCOMPARE(retId, 0U);
|
|
retId = listener->Notify("testApp2", replacesId, "some-icon2", "summary2", "body2", {}, {{}}, 3);
|
|
QCOMPARE(retId, 0U);
|
|
// but timeout == 0 is
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
plugin->config()->set("generalPersistent", false);
|
|
|
|
// if min-urgency is set, lower urgency levels are not synced:
|
|
plugin->config()->set("generalUrgency", 1);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{"urgency", 0}}, 0);
|
|
QCOMPARE(retId, 0U);
|
|
// equal urgency is
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{"urgency", 1}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
// higher urgency as well
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{"urgency", 2}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
plugin->config()->set("generalUrgency", 0);
|
|
|
|
// notifications for a deactivated application are not synced:
|
|
QVERIFY(listener->getApplications().contains("testApp"));
|
|
listener->getApplications()["testApp"].active = false;
|
|
QVERIFY(!listener->getApplications()["testApp"].active);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{"urgency", 0}}, 0);
|
|
QCOMPARE(retId, 0U);
|
|
// others are still:
|
|
retId = listener->Notify("testApp2", replacesId+1, "some-icon2", "summary2", "body2", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId+1);
|
|
// back to normal:
|
|
listener->getApplications()["testApp"].active = true;
|
|
QVERIFY(listener->getApplications()["testApp"].active);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
|
|
// notifications with blacklisted subjects are not synced:
|
|
QVERIFY(listener->getApplications().contains("testApp"));
|
|
listener->getApplications()["testApp"].blacklistExpression.setPattern("black[12]|foo(bar|baz)");
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary black1", "body", {}, {{}}, 0);
|
|
QCOMPARE(retId, 0U);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary foobar", "body", {}, {{}}, 0);
|
|
QCOMPARE(retId, 0U);
|
|
// other subjects are synced:
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary foo", "body", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary black3", "body", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
// also body is checked by blacklist if requested:
|
|
plugin->config()->set("generalIncludeBody", true);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body black1", {}, {{}}, 0);
|
|
QCOMPARE(retId, 0U);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body foobaz", {}, {{}}, 0);
|
|
QCOMPARE(retId, 0U);
|
|
// body does not matter if inclusion was not requested:
|
|
plugin->config()->set("generalIncludeBody", false);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body black1", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body foobaz", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
|
|
// back to normal:
|
|
listener->getApplications()["testApp"].blacklistExpression.setPattern("");
|
|
plugin->config()->set("generalIncludeBody", true);
|
|
retId = listener->Notify("testApp", replacesId, "some-icon", "summary", "body", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
retId = listener->Notify("testApp2", replacesId, "some-icon2", "summary2", "body2", {}, {{}}, 0);
|
|
QCOMPARE(retId, replacesId);
|
|
}
|
|
|
|
|
|
QTEST_GUILESS_MAIN(TestNotificationListener);
|
|
|
|
#include "testnotificationlistener.moc"
|