File indexing completed on 2024-05-19 04:45:14

 /*
     SPDX-FileCopyrightText: 2022 Volker Krause <vkrause@kde.org>
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include <KUnifiedPush/Connector>
 
 #include "../src/distributor/distributor.h"
 #include "../src/distributor/message.h"
 #include "../src/distributor/mockpushprovider.h"
 
 #include <QDBusConnection>
 #include <QLoggingCategory>
 #include <QSettings>
 #include <QSignalSpy>
 #include <QStandardPaths>
 #include <QTest>
 
 class ConnectorTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase()
     {
         QStandardPaths::setTestModeEnabled(true);
         qputenv("UNIFIEDPUSH_DISTRIBUTOR", "mock");
         qRegisterMetaType<KUnifiedPush::Connector::State>();
 
         QCoreApplication::setOrganizationDomain(QStringLiteral("kde.org"));
         QCoreApplication::setOrganizationName(QStringLiteral("KDE"));
 
         QSettings settings;
         settings.clear();
         settings.setValue(QStringLiteral("PushProvider/Type"), QStringLiteral("Mock"));
 
         QLoggingCategory::setFilterRules(QStringLiteral("org.kde.kunifiedpush.*=true"));
     }
 
     void init()
     {
         QSettings stateSettings(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1String("/kunifiedpush-org.kde.kunifiedpush.connectortest"), QSettings::IniFormat);
         stateSettings.clear();
     }
 
     void testNoDistributor()
     {
         KUnifiedPush::Connector con(QStringLiteral("org.kde.kunifiedpush.connectortest"));
         QCOMPARE(con.endpoint(), QString());
         QCOMPARE(con.state(), KUnifiedPush::Connector::NoDistributor);
     }
 
     void testWithDistributor()
     {
         using namespace KUnifiedPush;
         std::unique_ptr<Connector> con;
         std::unique_ptr<QSignalSpy> stateSpy;
         std::unique_ptr<QSignalSpy> endpointSpy;
 
         QVERIFY(QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kunifiedpush.connectortest")));
         con.reset(new Connector(QStringLiteral("org.kde.kunifiedpush.connectortest")));
         QCOMPARE(con->state(), KUnifiedPush::Connector::NoDistributor);
         stateSpy.reset(new QSignalSpy(con.get(), &Connector::stateChanged));
         endpointSpy.reset(new QSignalSpy(con.get(), &Connector::endpointChanged));
 
         Distributor dist;
         QCOMPARE(dist.status(), KUnifiedPush::DistributorStatus::Idle);
         QVERIFY(QDBusConnection::sessionBus().registerService(QStringLiteral("org.unifiedpush.Distributor.mock")));
 
         QVERIFY(MockPushProvider::s_instance);
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Unregistered);
 
         con->registerClient(QStringLiteral("Push notification unit test."));
         QCOMPARE(con->state(), KUnifiedPush::Connector::Registering);
         QVERIFY(stateSpy->wait());
         // FIXME: delayed D-Bus replies inside the same process seem not to be actually delayed, so state get messed up after this...
         // QCOMPARE(con.state(), KUnifiedPush::Connector::Registered);
         QVERIFY(endpointSpy->wait());
         QCOMPARE(endpointSpy->size(), 1);
         QCOMPARE(con->endpoint(), QLatin1String("https://localhost/push-endpoint"));
         QCOMPARE(dist.status(), KUnifiedPush::DistributorStatus::Connected);
 
         // connector restart does not register at the provider but uses existing state
         {
             con.reset();
             QTest::qWait(10); // propagate connector D-Bus tear-down
             con.reset(new Connector(QStringLiteral("org.kde.kunifiedpush.connectortest")));
             QCOMPARE(con->endpoint(), QLatin1String("https://localhost/push-endpoint"));
             QCOMPARE(con->state(), KUnifiedPush::Connector::Registering);
             stateSpy.reset(new QSignalSpy(con.get(), &Connector::stateChanged));
             endpointSpy.reset(new QSignalSpy(con.get(), &Connector::endpointChanged));
             QVERIFY(stateSpy->wait());
             QCOMPARE(con->state(), KUnifiedPush::Connector::Registered);
         }
 
         // distributor goes away and comes back
         QVERIFY(QDBusConnection::sessionBus().unregisterService(QStringLiteral("org.unifiedpush.Distributor.mock")));
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::NoDistributor);
         QVERIFY(QDBusConnection::sessionBus().registerService(QStringLiteral("org.unifiedpush.Distributor.mock")));
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Registering);
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Registered);
         QCOMPARE(dist.status(), KUnifiedPush::DistributorStatus::Connected);
 
         // receiving a message
         QSignalSpy msgSpy(con.get(), &Connector::messageReceived);
         KUnifiedPush::Message msg;
         msg.clientRemoteId = QStringLiteral("<client-remote-id>");
         msg.content = "hello world";
         Q_EMIT MockPushProvider::s_instance->messageReceived(msg);
         QVERIFY(msgSpy.wait());
         QCOMPARE(msgSpy.at(0).at(0).toByteArray(), "hello world");
 
         // reconfigure distributor to a different push provider
         dist.setPushProvider(QStringLiteral("Broken"), {});
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Unregistered);
         QCOMPARE(con->endpoint(), QString());
         QCOMPARE(dist.status(), KUnifiedPush::DistributorStatus::NoSetup);
 
         dist.setPushProvider(QStringLiteral("Mock"), {});
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Registered);
         QCOMPARE(con->endpoint(), QLatin1String("https://localhost/push-endpoint"));
 
         QVariantMap config;
         config.insert(QStringLiteral("setting"), true);
         dist.setPushProvider(QStringLiteral("Mock"), config);
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Unregistered);
         QCOMPARE(con->endpoint(), QString());
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Registered);
         QCOMPARE(con->endpoint(), QLatin1String("https://localhost/push-endpoint"));
         QCOMPARE(endpointSpy->size(), 4);
 
         // connector unregisters
         endpointSpy->clear();
         con->unregisterClient();
         QVERIFY(stateSpy->wait());
         QCOMPARE(con->state(), KUnifiedPush::Connector::Unregistered);
         QCOMPARE(endpointSpy->size(), 1);
         QCOMPARE(con->endpoint(), QString());
         QCOMPARE(dist.status(), KUnifiedPush::DistributorStatus::Idle);
     }
 };
 
 QTEST_GUILESS_MAIN(ConnectorTest)
 
 #include "connectortest.moc"
 #include "../src/shared/moc_distributorstatus_p.cpp"