test: add identify test

fix some bugs found in testing

Signed-off-by: ComixHe <heyuming@deepin.org>

tests/CMakeLists.txt

@@ -18,7 +18,16 @@ target_link_libraries(${BIN_NAME} PRIVATE
     dde_am_static
 )
 
-target_compile_options(${BIN_NAME} PRIVATE "-fno-access-control")
+target_compile_options(${BIN_NAME} PRIVATE
+    -fno-access-control
+    -fsanitize=undefined
+    -fsanitize=address
+)
+
+target_link_options(${BIN_NAME} PRIVATE
+    -fsanitize=undefined
+    -fsanitize=address
+)
 
 add_test(
     NAME UnitTest

tests/ut_applicationmanager.cpp

@@ -0,0 +1,154 @@
+// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "dbus/applicationmanager1service.h"
+#include "dbus/applicationservice.h"
+#include "cgroupsidentifier.h"
+#include "constant.h"
+#include <gtest/gtest.h>
+#include <QDBusConnection>
+#include <QSharedPointer>
+#include <sys/syscall.h>
+#include <QProcess>
+#include <thread>
+#include <chrono>
+#include <QDBusUnixFileDescriptor>
+
+namespace {
+int pidfd_open(pid_t pid, uint flags)
+{
+    return syscall(SYS_pidfd_open, pid, flags);
+}
+}  // namespace
+
+class TestApplicationManager : public testing::Test
+{
+public:
+    static void SetUpTestCase()
+    {
+        auto &bus = ApplicationManager1DBus::instance();
+        bus.initGlobalServerBus(DBusType::Session);
+        bus.setDestBus();
+
+        m_am = new ApplicationManager1Service{std::make_unique<CGroupsIdentifier>(), bus.globalServerBus()};
+
+        DesktopFile file{"/usr/share/applications/test-Application.desktop", "test-Application", 0};
+        QSharedPointer<ApplicationService> app = QSharedPointer<ApplicationService>::create(std::move(file));
+        QSharedPointer<InstanceService> instance =
+            QSharedPointer<InstanceService>::create(InstancePath.path().split('/').last(), ApplicationPath.path(), QString{"/"});
+        app->m_Instances.insert(InstancePath, instance);
+        m_am->m_applicationList.insert(ApplicationPath, app);
+    }
+
+    static void TearDownTestCase() { m_am->deleteLater(); }
+
+    static inline ApplicationManager1Service *m_am{nullptr};
+    const static inline QDBusObjectPath ApplicationPath{DDEApplicationManager1ApplicationObjectPath +
+                                                        QUuid::createUuid().toString(QUuid::Id128)};
+    const static inline QDBusObjectPath InstancePath{DDEApplicationManager1InstanceObjectPath +
+                                                     QUuid::createUuid().toString(QUuid::Id128)};
+};
+
+TEST_F(TestApplicationManager, list)
+{
+    auto lists = m_am->list();
+    EXPECT_EQ(lists.first(), ApplicationPath);
+}
+
+TEST_F(TestApplicationManager, application)
+{
+    EXPECT_EQ(m_am->Application("test-Application"), ApplicationPath);
+}
+
+TEST_F(TestApplicationManager, identifyService)
+{
+    using namespace std::chrono_literals;
+    // for service unit
+    auto workingDir = QDir::cleanPath(QDir::current().absolutePath() + QDir::separator() + ".." + QDir::separator() + "tools");
+    QFile pidFile{workingDir + QDir::separator() + "pid.txt"};
+    if (pidFile.exists()) {
+        ASSERT_TRUE(pidFile.remove());
+    }
+
+    QProcess fakeServiceProc;
+    fakeServiceProc.setWorkingDirectory(workingDir);
+    auto InstanceId = InstancePath.path().split('/').last();
+    fakeServiceProc.start("/usr/bin/systemd-run",
+                          {{QString{R"(--unit=app-DDE-test\x2dApplication@%1.service)"}.arg(InstanceId)},
+                           {"--user"},
+                           {QString{"--working-directory=%1"}.arg(workingDir)},
+                           {"--slice=app.slice"},
+                           {"./fake-process.sh"}});
+    fakeServiceProc.waitForFinished();
+    if (fakeServiceProc.exitStatus() != QProcess::ExitStatus::NormalExit) {
+        GTEST_SKIP() << "invoke systemd-run failed.";
+    }
+
+    std::this_thread::sleep_for(100ms);
+
+    auto success = pidFile.open(QFile::ReadOnly | QFile::Text | QFile::ExistingOnly);
+    EXPECT_TRUE(success);
+
+    if (!success) {
+        qWarning() << pidFile.errorString();
+        fakeServiceProc.terminate();
+        ASSERT_TRUE(false);
+    }
+
+    bool ok{false};
+    auto fakePid = pidFile.readLine().toInt(&ok);
+    ASSERT_TRUE(ok);
+
+    auto pidfd = pidfd_open(fakePid, 0);
+    ASSERT_TRUE(pidfd > 0) << std::strerror(errno);
+    QDBusObjectPath application;
+    QDBusObjectPath application_instance;
+    auto appId = m_am->Identify(QDBusUnixFileDescriptor{pidfd}, application, application_instance);
+    EXPECT_EQ(appId.toStdString(), QString{"test-Application"}.toStdString());
+    EXPECT_EQ(application.path().toStdString(), ApplicationPath.path().toStdString());
+    EXPECT_EQ(application_instance.path().toStdString(), InstancePath.path().toStdString());
+    close(pidfd);
+
+    if (pidFile.exists()) {
+        pidFile.remove();
+    }
+
+    // for scope unit
+    ASSERT_TRUE(QProcess::startDetached("/usr/bin/systemd-run",
+                                        {{"--scope"},
+                                         {QString{R"(--unit=app-DDE-test\x2dApplication-%1.scope)"}.arg(InstanceId)},
+                                         {"--user"},
+                                         {QString{"--working-directory=%1"}.arg(workingDir)},
+                                         {"--slice=app.slice"},
+                                         {"./fake-process.sh"},
+                                         {"Scope"}},
+                                        workingDir));
+
+    std::this_thread::sleep_for(100ms);
+
+    success = pidFile.open(QFile::ReadOnly | QFile::Text | QFile::ExistingOnly);
+    EXPECT_TRUE(success);
+
+    if (!success) {
+        qWarning() << pidFile.errorString();
+        ASSERT_TRUE(false);
+    }
+
+    ok = false;
+    fakePid = pidFile.readLine().toInt(&ok);
+    ASSERT_TRUE(ok);
+
+    pidfd = pidfd_open(fakePid, 0);
+    ASSERT_TRUE(pidfd > 0) << std::strerror(errno);
+
+    appId = m_am->Identify(QDBusUnixFileDescriptor{pidfd}, application, application_instance);
+    EXPECT_EQ(appId.toStdString(), QString{"test-Application"}.toStdString());
+    EXPECT_EQ(application.path().toStdString(), ApplicationPath.path().toStdString());
+    EXPECT_EQ(application_instance.path().toStdString(), InstancePath.path().toStdString());
+    close(pidfd);
+
+    if (pidFile.exists()) {
+        pidFile.remove();
+    }
+}

tests/ut_desktopentry.cpp

@@ -30,8 +30,6 @@ public:
 
     static void TearDownTestCase() { qputenv("XDG_DATA_DIRS", env); }
 
-    void SetUp() override {}
-    void TearDown() override {}
     QSharedPointer<DesktopFile> file() { return m_file; }
 
 private:

tests/ut_jobmanager.cpp

@@ -43,5 +43,5 @@ TEST_F(TestJobManager, addJob)
             return QVariant::fromValue(true);
         },
         args);
-    QThread::sleep(1);  // force wait
+    QThreadPool::globalInstance()->waitForDone();
 }