File indexing completed on 2024-05-12 04:38:22

 /*
     SPDX-FileCopyrightText: 2008 Andreas Pakulat <apaku@gmx.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "test_sessioncontroller.h"
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include "../core.h"
 #include "../sessioncontroller.h"
 #include "../session.h"
 #include <QDebug>
 #include <QFileInfo>
 #include <QSignalSpy>
 #include <QTest>
 
 using namespace KDevelop;
 
 //////////////////// Helper Functions ////////////////////////////////////////
 
 QString sessionDir( ISession* s )
 {
     return SessionController::sessionDirectory(s->id().toString());
 }
 
 void verifySessionDir( const QString& sessiondir, const QString& name, bool exists )
 {
     if( exists )
     {
         qDebug() << "checking existing session" << sessiondir;
         QVERIFY( QFileInfo::exists( sessiondir ) );
         QVERIFY( QFileInfo( sessiondir ).isDir() );
         QVERIFY( QFileInfo::exists( sessiondir+"/sessionrc" ) );
         KSharedConfigPtr cfg = KSharedConfig::openConfig( sessiondir+"/sessionrc" );
         QCOMPARE( name, cfg->group("").readEntry( Session::cfgSessionNameEntry, "" ) );
     } else {
         qDebug() << "checking not-existing dir: " << sessiondir;
         QVERIFY( !QFileInfo::exists( sessiondir ) );
     }
 }
 
 void verifySessionDir( ISession* s, bool exists = true )
 {
     verifySessionDir(sessionDir(s), s->name(), exists);
 }
 
 ////////////////////// Fixture ///////////////////////////////////////////////
 
 void TestSessionController::initTestCase()
 {
     AutoTestShell::init();
     TestCore::initialize(Core::NoUi);
     m_core = Core::self();
     qRegisterMetaType<KDevelop::ISession*>();
     qRegisterMetaType<KDevelop::Session*>();
 }
 
 void TestSessionController::init()
 {
     m_sessionCtrl = m_core->sessionController();
 }
 
 void TestSessionController::cleanupTestCase()
 {
     const auto sessions = m_sessionCtrl->sessions();
     for (const Session* session : sessions) {
         TryLockSessionResult lock = m_sessionCtrl->tryLockSession(session->id().toString());
         if (lock.lock)
             m_sessionCtrl->deleteSession( lock.lock );
     }
 
     TestCore::shutdown();
 }
 
 void TestSessionController::createSession_data()
 {
     QTest::addColumn<QString>( "sessionName" );
     QTest::newRow("SimpleName") << "TestSession";
     QTest::newRow("NonLetterChars") << "Test%$Session";
     QTest::newRow("NonAsciiChars") << QStringLiteral("TöstSession");
 }
 
 void TestSessionController::createSession()
 {
     QFETCH(QString, sessionName);
     int sessionCount = m_sessionCtrl->sessionNames().count();
     Session* s = m_sessionCtrl->createSession( sessionName );
     QVERIFY( m_sessionCtrl->sessionNames().contains( sessionName )  );
     QCOMPARE( sessionCount+1, m_sessionCtrl->sessionNames().count() );
     verifySessionDir( s );
 }
 
 void TestSessionController::renameSession()
 {
     const QString sessionName = QStringLiteral("TestSession4");
     const QString newSessionName = QStringLiteral("TestOtherSession4");
     KDevelop::Session *s = m_sessionCtrl->createSession( sessionName );
     QCOMPARE( sessionName, s->name() );
     verifySessionDir( s );
     QSignalSpy spy(s, SIGNAL(sessionUpdated(KDevelop::ISession*)));
     s->setName( newSessionName );
     QCOMPARE( newSessionName, s->name() );
     QCOMPARE( spy.size(), 1 );
 
     verifySessionDir( s );
 }
 
 void TestSessionController::canRenameActiveSession()
 {
     const QString sessionName = QStringLiteral("TestSession5");
     const QString newSessionName = QStringLiteral("TestOtherSession5");
     KDevelop::Session *s = m_sessionCtrl->createSession( sessionName );
     QCOMPARE( sessionName, s->name() );
     m_sessionCtrl->loadSession( sessionName );
     QSignalSpy spy(s, SIGNAL(sessionUpdated(KDevelop::ISession*)));
     s->setName( newSessionName );
     QCOMPARE( newSessionName, s->name() );
     QCOMPARE( spy.size(), 1 );
 
     verifySessionDir( s );
 }
 
 void TestSessionController::deleteSession()
 {
     const QString sessionName = QStringLiteral("TestSession3");
     int sessionCount = m_sessionCtrl->sessionNames().count();
     QPointer<Session> s = m_sessionCtrl->createSession( sessionName );
     QString sessionId = s->id().toString();
     QCOMPARE( sessionCount+1, m_sessionCtrl->sessionNames().count() );
     verifySessionDir( s.data() );
     const QString sessionDir = ::sessionDir(s);
 
     QSignalSpy spy(m_sessionCtrl, SIGNAL(sessionDeleted(QString)));
     {
         TryLockSessionResult lock = m_sessionCtrl->tryLockSession(sessionId);
         QVERIFY(lock.lock);
         m_sessionCtrl->deleteSession( lock.lock );
     }
     QCOMPARE( sessionCount, m_sessionCtrl->sessionNames().count() );
     QVERIFY( !m_sessionCtrl->sessionNames().contains(sessionId) );
 
     QCOMPARE(spy.size(), 1);
     QList<QVariant> arguments = spy.takeFirst();
 
     QString emittedSession = arguments.at(0).toString();
     QCOMPARE( sessionId, emittedSession );
 
     verifySessionDir( sessionDir, sessionName, false );
 }
 
 void TestSessionController::cloneSession()
 {
     QString sessionName = QStringLiteral("CloneableSession");
     QString testgrp = QStringLiteral("TestGroup");
     QString testentry = QStringLiteral("TestEntry");
     QString testval = QStringLiteral("TestValue");
     int sessionCount = m_sessionCtrl->sessionNames().count();
     m_sessionCtrl->createSession( sessionName );
     Session* s = m_sessionCtrl->session( sessionName );
     s->config()->group( testgrp ).writeEntry( testentry, testval );
     s->config()->sync();
     QCOMPARE( sessionCount+1, m_sessionCtrl->sessionNames().count() );
     QVERIFY( m_sessionCtrl->session( sessionName ) );
 
     QString newSession = m_sessionCtrl->cloneSession( sessionName );
     QVERIFY( m_sessionCtrl->session( newSession ) );
     QCOMPARE( sessionCount+2, m_sessionCtrl->sessionNames().count() );
     Session* news = m_sessionCtrl->session( newSession );
     QCOMPARE( testval, news->config()->group( testgrp ).readEntry( testentry, "" ) );
     QCOMPARE( i18n( "Copy of %1", sessionName ), news->name() );
 
     verifySessionDir( news );
 
 
 }
 
 void TestSessionController::readFromConfig()
 {
     ISession* s = Core::self()->activeSession();
     KConfigGroup grp( s->config(), "TestGroup" );
     grp.writeEntry( "TestEntry", "Test1" );
     KConfigGroup grp2( s->config(), "TestGroup" );
     QCOMPARE(grp.readEntry( "TestEntry", "" ), QStringLiteral( "Test1" ) );
 }
 
 void TestSessionController::temporary()
 {
     ISession* s = Core::self()->activeSession();
     s->setTemporary(true);
     const QString oldName = s->name();
     const QString dir = sessionDir(s);
 
     verifySessionDir(s, true);
     Core::self()->sessionController()->cleanup();
     verifySessionDir(dir, oldName, false);
     Core::self()->sessionController()->initialize(oldName);
     QCOMPARE(Core::self()->activeSession()->name(), oldName);
     // dir / UID can be different, hence don't verifySessionDir
 }
 
 void TestSessionController::tryLockSession()
 {
     const QString id1 = QUuid::createUuid().toString();
     m_sessionCtrl->createSession( id1 )->setTemporary(true);
     const QString id2 = QUuid::createUuid().toString();
     m_sessionCtrl->createSession( id2 )->setTemporary(true);
     {
         // acquired scoped lock
         QVERIFY(!SessionController::isSessionRunning(id1));
         QCOMPARE(SessionController::sessionRunInfo(id1), SessionRunInfo());
         TryLockSessionResult initial = SessionController::tryLockSession(id1);
         QVERIFY(initial.lock);
         QCOMPARE(initial.lock->id(), id1);
         QCOMPARE(initial.runInfo, SessionRunInfo());
         QVERIFY(SessionController::isSessionRunning(id1));
 
         SessionRunInfo info = SessionController::sessionRunInfo(id1);
         QVERIFY(info != initial.runInfo);
         QVERIFY(info.isRunning);
         QCOMPARE(info.holderApp, QCoreApplication::applicationName());
         QCOMPARE(info.holderPid, static_cast<int>(QCoreApplication::applicationPid()));
 
         // this should fail
         TryLockSessionResult repeated = SessionController::tryLockSession(id1);
         QVERIFY(!repeated.lock);
         QCOMPARE(repeated.runInfo, info);
 
         // this should pass (different id)
         QVERIFY(!SessionController::isSessionRunning(id2));
         TryLockSessionResult other = SessionController::tryLockSession(id2);
         QVERIFY(other.lock);
         QCOMPARE(other.lock->id(), id2);
         QCOMPARE(other.runInfo, SessionRunInfo());
         QVERIFY(SessionController::isSessionRunning(id2));
     }
 
     // scope left, sessions are now unlocked again
     QVERIFY(!SessionController::isSessionRunning(id1));
     QCOMPARE(SessionController::sessionRunInfo(id1), SessionRunInfo());
     QVERIFY(!SessionController::isSessionRunning(id2));
     QCOMPARE(SessionController::sessionRunInfo(id2), SessionRunInfo());
 
     // can re-lock it here
     TryLockSessionResult final = SessionController::tryLockSession(id1);
     QVERIFY(SessionController::isSessionRunning(id1));
     QVERIFY(final.lock);
     QCOMPARE(final.lock->id(), id1);
     QCOMPARE(final.runInfo, SessionRunInfo());
 }
 
 QTEST_GUILESS_MAIN(TestSessionController)
 
 #include "moc_test_sessioncontroller.cpp"