1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include <QtTest/QtTest>

    42 #include <QtCore>

    43 #define private public

    44 #include <qserviceinterfacedescriptor.h>

    45 #include <qserviceinterfacedescriptor_p.h>

    46 #include "../qsfwtestutil.h"

    47 #include <databasemanager_p.h>

    48 

    49 #if defined(Q_OS_SYMBIAN)

    50 # define TESTDATA_DIR "."

    51 #endif

    52 

    53 QTM_USE_NAMESPACE

    54 

    55 class tst_DatabaseManager: public QObject

    56 {

    57     Q_OBJECT

    58 private slots:

    59         void initTestCase();

    60         void registerService();

    61         void getInterfaces();

    62         void getServiceNames();

    63         void defaultService();

    64         void unregisterService();

    65 #ifdef Q_OS_UNIX        

    66 	void permissions();

    67         void onlyUserDbAvailable();

    68         void defaultServiceCornerCases();

    69 #endif

    70         void nonWritableSystemDb();

    71         void CWRTXmlCompatability();

    72         void cleanupTestCase();

    73 private:

    74        bool compareDescriptor(QServiceInterfaceDescriptor interface,

    75                 QString interfaceName,

    76                 QString serviceName,

    77                 int majorVersion,

    78                 int minorVersion);

    79 

    80        bool compareDescriptor(QServiceInterfaceDescriptor interface,

    81                QString interfaceName,

    82                QString serviceName,

    83                int majorVersion,

    84                int minorVersion,

    85                QStringList capabilities,

    86                QString filePath="",

    87                QString serviceDescription="",

    88                QString interfaceDescription="");

    89 

    90         void clean();

    91         void modifyPermissionSet(QFile::Permissions &permsSet,

    92                                             int perm);

    93 

    94         DatabaseManager *m_dbm;

    95         QDir m_testdir;

    96 };

    97 

    98 void tst_DatabaseManager::initTestCase()

    99 {

   100     QSfwTestUtil::setupTempUserDb();

   101     QSfwTestUtil::setupTempSystemDb();

   102     QSfwTestUtil::removeDirectory(QSfwTestUtil::tempSettingsPath());

   103     m_dbm = new DatabaseManager;

   104 }

   105 

   106 void tst_DatabaseManager::registerService()

   107 {

   108     m_testdir = QDir(TESTDATA_DIR "/testdata");

   109     ServiceMetaData parser("");

   110 

   111     QStringList userServiceFiles;

   112     userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"

   113                     << "ServicePrimatech.xml"

   114                     << "ServiceDharma_Swan.xml"

   115                     << "ServiceDharma_Pearl.xml"

   116                     << "ServiceDharma_Flame.xml"

   117                     << "ServiceDecepticon.xml";

   118 

   119     foreach (const QString &serviceFile, userServiceFiles) {

   120         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

   121         QVERIFY(parser.extractMetadata());

   122         ServiceMetaDataResults results = parser.parseResults();

   123         QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

   124     }

   125 

   126     QStringList systemServiceFiles;

   127     systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"

   128                         << "ServiceDharma_Hydra.xml"

   129                         << "ServiceDharma_Orchid.xml"

   130                         << "ServiceAutobot.xml";

   131     foreach (const QString &serviceFile, systemServiceFiles) {

   132         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

   133         QVERIFY(parser.extractMetadata());

   134         ServiceMetaDataResults results = parser.parseResults();

   135         QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));

   136     }

   137 }

   138 

   139 void tst_DatabaseManager::getInterfaces()

   140 {

   141     QString iface("com.omni.device.accelerometer");

   142     QServiceFilter filter(iface);

   143     QList<QServiceInterfaceDescriptor> descriptors;

   144     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   145     QCOMPARE(descriptors.count(), 5);

   146     QVERIFY(compareDescriptor(descriptors[0], iface, "LuthorCorp", 1,2));

   147     QCOMPARE(descriptors[0].scope(), QService::UserScope);

   148     QVERIFY(compareDescriptor(descriptors[1], iface, "Primatech", 1, 4));

   149     QCOMPARE(descriptors[1].scope(), QService::UserScope);

   150     QVERIFY(compareDescriptor(descriptors[2], iface, "Primatech", 1, 2));

   151     QCOMPARE(descriptors[2].scope(), QService::UserScope);

   152     QVERIFY(compareDescriptor(descriptors[3], iface, "OMNI", 1, 1));

   153     QCOMPARE(descriptors[3].scope(), QService::SystemScope);

   154     QVERIFY(compareDescriptor(descriptors[4], iface, "WayneEnt", 2, 0));

   155     QCOMPARE(descriptors[4].scope(), QService::SystemScope);

   156 

   157     //check that we can get descriptors for a service spread

   158     //over the user and system databases

   159     filter.setServiceName("DharmaInitiative");

   160     filter.setInterface("");

   161     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   162     QCOMPARE(descriptors.count(),10);

   163 

   164     QStringList capabilities;

   165     QVERIFY(compareDescriptor(descriptors[0], "com.dharma.electro.discharge", "DharmaInitiative", 4, 0, capabilities, "C:/island/swan.dll"));

   166     QCOMPARE(descriptors[0].scope(), QService::UserScope);

   167     QVERIFY(compareDescriptor(descriptors[1],  "com.dharma.electro.discharge","DharmaInitiative", 8, 0, capabilities, "C:/island/pearl.dll"));

   168     QCOMPARE(descriptors[1].scope(), QService::UserScope);

   169     QVERIFY(compareDescriptor(descriptors[2], "com.dharma.electro.discharge", "DharmaInitiative", 15, 0, capabilities, "C:/island/flame.dll"));

   170     QCOMPARE(descriptors[2].scope(), QService::UserScope);

   171     QVERIFY(compareDescriptor(descriptors[3], "com.dharma.radio", "DharmaInitiative", 8, 15, capabilities, "C:/island/flame.dll"));

   172     QCOMPARE(descriptors[3].scope(), QService::UserScope);

   173     QVERIFY(compareDescriptor(descriptors[4], "com.dharma.electro.discharge", "DharmaInitiative", 16, 0, capabilities, "C:/island/flame.dll"));

   174     QCOMPARE(descriptors[4].scope(), QService::UserScope);

   175     QVERIFY(compareDescriptor(descriptors[5], "com.dharma.electro.discharge", "DharmaInitiative", 23, 0, capabilities, "C:/island/hydra.dll"));

   176     QCOMPARE(descriptors[5].scope(), QService::SystemScope);

   177     QVERIFY(compareDescriptor(descriptors[6], "com.dharma.electro.discharge", "DharmaInitiative", 42, 0, capabilities, "C:/island/hydra.dll"));

   178     QCOMPARE(descriptors[6].scope(), QService::SystemScope);

   179     QVERIFY(compareDescriptor(descriptors[7], "com.dharma.cage", "DharmaInitiative", 3, 16, capabilities, "C:/island/hydra.dll"));

   180     QCOMPARE(descriptors[7].scope(), QService::SystemScope);

   181     //note; the following system interface implementation overlaps with an interface implementation already provided in the user database

   182     QVERIFY(compareDescriptor(descriptors[8], "com.dharma.electro.discharge", "DharmaInitiative", 4, 0, capabilities, "C:/island/orchid.dll"));

   183     QCOMPARE(descriptors[8].scope(), QService::SystemScope);

   184     QVERIFY(compareDescriptor(descriptors[9], "com.dharma.wheel", "DharmaInitiative", 1, 0, capabilities, "C:/island/orchid.dll"));

   185     QCOMPARE(descriptors[9].scope(), QService::SystemScope);

   186 

   187     //do a system database only search

   188     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

   189     QCOMPARE(descriptors.count(), 5);

   190     QVERIFY(compareDescriptor(descriptors[0], "com.dharma.electro.discharge", "DharmaInitiative", 23, 0, capabilities, "C:/island/hydra.dll"));

   191     QCOMPARE(descriptors[0].scope(), QService::SystemScope);

   192     QVERIFY(compareDescriptor(descriptors[1], "com.dharma.electro.discharge", "DharmaInitiative", 42, 0, capabilities, "C:/island/hydra.dll"));

   193     QCOMPARE(descriptors[1].scope(), QService::SystemScope);

   194     QVERIFY(compareDescriptor(descriptors[2], "com.dharma.cage", "DharmaInitiative", 3, 16, capabilities, "C:/island/hydra.dll"));

   195     QCOMPARE(descriptors[2].scope(), QService::SystemScope);

   196     QVERIFY(compareDescriptor(descriptors[3], "com.dharma.electro.discharge", "DharmaInitiative", 4, 0, capabilities, "C:/island/orchid.dll"));

   197     QCOMPARE(descriptors[3].scope(), QService::SystemScope);

   198     QVERIFY(compareDescriptor(descriptors[4], "com.dharma.wheel", "DharmaInitiative", 1, 0, capabilities, "C:/island/orchid.dll"));

   199     QCOMPARE(descriptors[4].scope(), QService::SystemScope);

   200 

   201     //search for a non-existent interface

   202     filter.setServiceName("");

   203     filter.setInterface("com.omni.device.fluxcapacitor");

   204     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   205     QCOMPARE(descriptors.count(), 0);

   206     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   207 }

   208 

   209 void tst_DatabaseManager::getServiceNames()

   210 {

   211     //try getting a lost of service names only in user database

   212     QStringList serviceNames;

   213     serviceNames = m_dbm->getServiceNames("", DatabaseManager::UserOnlyScope);

   214     QStringList expectedNames;

   215     expectedNames << "acme" << "LuthorCorp" << "Primatech" << "DharmaInitiative" << "Decepticon";

   216     QCOMPARE(serviceNames.count(), expectedNames.count());

   217     foreach(const QString &expectedName, expectedNames)

   218         QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));

   219 

   220     //try getting a list of service names in the system database

   221     serviceNames = m_dbm->getServiceNames("", DatabaseManager::SystemScope);

   222     expectedNames.clear();

   223     expectedNames << "OMNI" << "WayneEnt" << "DharmaInitiative" << "Autobot";

   224     QCOMPARE(serviceNames.count(), expectedNames.count());

   225     foreach(const QString &expectedName, expectedNames)

   226         QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));

   227 

   228     //try getting a list of service names from both databases

   229     //and ensure there are no duplicates

   230     serviceNames = m_dbm->getServiceNames("", DatabaseManager::UserScope);

   231     expectedNames.clear();

   232     expectedNames << "acme" << "LuthorCorp" << "Primatech" << "omni" << "WayneEnt"

   233                     << "DharmaInitiative" << "Autobot" << "Decepticon";

   234     QCOMPARE(serviceNames.count(), expectedNames.count());

   235     foreach(const QString &expectedName, expectedNames)

   236         QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));

   237 

   238     //try getting names of services that implement particular interface

   239     serviceNames = m_dbm->getServiceNames("com.omni.device.accelerometer", DatabaseManager::UserScope);

   240     expectedNames.clear();

   241     expectedNames << "LuthorCorp" << "Primatech" << "omni" << "WayneEnt";

   242     QCOMPARE(serviceNames.count(), expectedNames.count());

   243     foreach(const QString &expectedName, expectedNames)

   244         QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));

   245 }

   246 

   247 void tst_DatabaseManager::defaultService()

   248 {

   249     QServiceInterfaceDescriptor descriptor;

   250 

   251     //get a user default service at user scope

   252     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   253                                                     DatabaseManager::UserScope);

   254     QVERIFY(compareDescriptor(descriptor,"com.omni.device.accelerometer", "LuthorCorp", 1, 2));

   255     QVERIFY(descriptor.scope()==QService::UserScope);

   256 

   257     //get a sytem default from user scope

   258     descriptor = m_dbm->interfaceDefault("com.Dharma.wheel", DatabaseManager::UserScope);

   259     QVERIFY(compareDescriptor(descriptor,"com.dharma.wheel", "DharmaInitiative", 1,0));

   260     QVERIFY(descriptor.scope() == QService::SystemScope);

   261 

   262     //get a system default service at system scope

   263     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   264                                                      DatabaseManager::SystemScope);

   265     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "omni", 1, 1));

   266 

   267     //set a user default from a user interface implementation

   268     QList<QServiceInterfaceDescriptor> descriptors;

   269     QServiceFilter filter;

   270     filter.setServiceName("Primatech");

   271     filter.setInterface("com.omni.device.accelerometer", "1.4");

   272     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   273     QCOMPARE(descriptors.count(), 1);

   274 

   275     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));

   276     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   277                                                     DatabaseManager::UserScope);

   278     QVERIFY(compareDescriptor(descriptor,"com.omni.device.accelerometer", "Primatech", 1, 4));

   279     QVERIFY(descriptor.scope() == QService::UserScope);

   280 

   281     //set a system default from a  system interface implementation

   282     filter.setServiceName("WayneEnt");

   283     filter.setInterface("com.omni.device.accelerometer","2.0");

   284     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

   285     QCOMPARE(descriptors.count(), 1);

   286 

   287     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::SystemScope));

   288     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   289                                                     DatabaseManager::SystemScope);

   290     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "WayneEnt", 2,0));

   291     QVERIFY(descriptor.scope() == QService::SystemScope );

   292 

   293     //set a user default with a system interface descriptor

   294     filter.setServiceName("omni");

   295     filter.setInterface("com.omni.device.accelerometer","1.1");

   296     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

   297     QCOMPARE(descriptors.count(), 1);

   298     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));

   299     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   300                                                 DatabaseManager::UserScope);

   301     QVERIFY(descriptor.isValid());

   302     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "omni", 1, 1));

   303     QVERIFY(descriptor.scope() == QService::SystemScope );

   304 

   305     //set a system default using a user interface descriptor

   306     filter.setServiceName("Primatech");

   307     filter.setInterface("com.omni.device.accelerometer","1.4");

   308     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   309     QCOMPARE(descriptors.count(), 1);

   310 

   311     QVERIFY(!m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::SystemScope));

   312     QCOMPARE(m_dbm->lastError().code(), DBError::InvalidDescriptorScope);

   313 

   314     // == try setting defaults using setInterfaceDefault(serviceName, interfaceName, ...)

   315     //set a local default in the user scope database

   316     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   317                                                 DatabaseManager::UserScope);

   318     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "omni", 1, 1));

   319     QVERIFY(m_dbm->setInterfaceDefault("LuthorCorp", "com.omni.device.accelerometer",

   320                                         DatabaseManager::UserScope));

   321     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   322                                                 DatabaseManager::UserScope);

   323     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "LuthorCorp", 1, 2));

   324 

   325     //set a system default in the user scope database

   326     descriptor = m_dbm->interfaceDefault("com.dharma.electro.disCHARGE",

   327                                                 DatabaseManager::UserScope);

   328     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

   329                             "DharmaInitiative", 4, 0));

   330     QVERIFY(descriptor.scope() == QService::UserScope);

   331     m_dbm->setInterfaceDefault("DharmaInitiative", "com.dharma.electro.discharge",

   332                                         DatabaseManager::UserScope);

   333 

   334     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

   335                                                 DatabaseManager::UserScope);

   336     QVERIFY(m_dbm->lastError().code() == DBError::NoError);

   337     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

   338                                 "DharmaInitiative", 42, 0));

   339 

   340     //set a user default in the user scope database but where there

   341     //exist interface implementations in both user and system databases

   342     //also check that the system scope default has not changed

   343     filter.setServiceName("Autobot");

   344     filter.setInterface("com.cybertron.transform", "2.5", QServiceFilter::ExactVersionMatch );

   345     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   346     QCOMPARE(descriptors.count(), 1);

   347     m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope);

   348     descriptor = m_dbm->interfaceDefault("com.cybertron.transform",

   349                                         DatabaseManager::UserScope);

   350     QVERIFY(compareDescriptor(descriptors[0], "com.cybertron.transform",

   351                                 "Autobot", 2, 5));

   352     descriptor = m_dbm->interfaceDefault("com.cybertron.transform",

   353                                         DatabaseManager::SystemScope);

   354     QVERIFY(compareDescriptor(descriptors[0], "com.cybertron.transform",

   355                                 "Autobot", 2, 5));

   356 

   357     m_dbm->setInterfaceDefault("Decepticon", "com.cybertron.transform", DatabaseManager::UserScope);

   358     descriptor = m_dbm->interfaceDefault("com.cybertron.transform",

   359                                         DatabaseManager::UserScope);

   360     QVERIFY(compareDescriptor(descriptor, "com.cybertron.transform",

   361                                 "Decepticon", 5,3));

   362     descriptor = m_dbm->interfaceDefault("com.cybertron.transform",

   363                                         DatabaseManager::SystemScope);

   364     QVERIFY(compareDescriptor(descriptors[0], "com.cybertron.transform",

   365                                 "Autobot", 2, 5));

   366 

   367     //Look up a default service for a non-existent interface

   368     descriptor = m_dbm->interfaceDefault("com.omni.device.fluxcapacitor", DatabaseManager::UserScope);

   369     QVERIFY(!descriptor.isValid());

   370     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   371 }

   372 

   373 void tst_DatabaseManager::unregisterService()

   374 {

   375     //try remove a service that only exists in the user database

   376     QServiceFilter filter;

   377     filter.setServiceName("acme");

   378     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);

   379     m_dbm->unregisterService("acme", DatabaseManager::UserScope);

   380     QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), 0);

   381 

   382     //try remove  a service that only exists in the system database

   383     filter.setServiceName("omni");

   384     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);

   385     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);

   386     m_dbm->unregisterService("omni", DatabaseManager::SystemScope);

   387     QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count(), 0);

   388     QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), 0);

   389 

   390     //try remove a service from the user database that also exists in the system database

   391     filter.setServiceName("dharmainitiative");

   392     int systemCount = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count();

   393     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);

   394     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);

   395     m_dbm->unregisterService("dharmainitiative", DatabaseManager::UserScope);

   396     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);

   397     QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), systemCount);

   398 

   399     //re-add the service to the user database for the next test

   400     ServiceMetaData parser("");

   401     parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceDharma_Swan.xml")));

   402     QVERIFY(parser.extractMetadata());

   403     ServiceMetaDataResults results = parser.parseResults();

   404     QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

   405 

   406     //try to remove a service from the system database that also exist in the user database

   407     filter.setServiceName("dharmainitiative");

   408     int userCount = m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count()

   409                     - m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count();

   410     QVERIFY(userCount > 0);

   411     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);

   412     QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);

   413     m_dbm->unregisterService("dharmainitiative", DatabaseManager::SystemScope);

   414     QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count(), 0);

   415     QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), userCount);

   416 

   417     //try and drop a table in the database by SQL injection

   418     QVERIFY(!m_dbm->unregisterService("; drop table Interface;", DatabaseManager::UserScope));

   419     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   420 

   421     clean();

   422 }

   423 

   424 bool tst_DatabaseManager::compareDescriptor(QServiceInterfaceDescriptor interface,

   425         QString interfaceName, QString serviceName, int majorVersion, int minorVersion)

   426 {

   427     if (interface.d == NULL )

   428         return false;

   429     interface.d->attributes[QServiceInterfaceDescriptor::Capabilities] = QStringList();

   430 

   431     return compareDescriptor(interface, interfaceName, serviceName, majorVersion, minorVersion,

   432             QStringList());

   433 }

   434 

   435 bool tst_DatabaseManager::compareDescriptor(QServiceInterfaceDescriptor interface,

   436     QString interfaceName, QString serviceName, int majorVersion, int minorVersion,

   437     QStringList capabilities, QString filePath, QString serviceDescription,

   438     QString interfaceDescription)

   439 {

   440 

   441     if(interface.interfaceName().compare(interfaceName, Qt::CaseInsensitive) !=0) {

   442         qWarning() << "Interface name mismatch: expected =" << interfaceName

   443                     << " actual =" << interface.interfaceName();

   444         return false;

   445     }

   446 

   447     if (interface.serviceName().compare(serviceName, Qt::CaseInsensitive) != 0) {

   448         qWarning() << "Service name mismatch: expected =" << serviceName

   449                     << " actual =" << interface.serviceName();

   450         return false;

   451     }

   452 

   453     if (interface.majorVersion() != majorVersion) {

   454         qWarning() << "Major version mismatch: expected =" << majorVersion

   455                         << " actual =" << interface.majorVersion();

   456         return false;

   457     }

   458 

   459     if (interface.minorVersion() != minorVersion) {

   460         qWarning() << "Minor version mismatch: expected =" << minorVersion

   461                     << " actual =" << interface.minorVersion();

   462         return false;

   463     }

   464 

   465     if (capabilities.count() != 0 || interface.attribute(QServiceInterfaceDescriptor::Capabilities).toStringList().count() != 0 ) {

   466         QStringList securityCapabilities;

   467         securityCapabilities = interface.attribute(QServiceInterfaceDescriptor::Capabilities).toStringList();

   468 

   469         if(securityCapabilities.count() != capabilities.count()) {

   470             qWarning() << "Capabilities count mismatch: expected =" << capabilities.count()

   471                         << " actual="<< securityCapabilities.count()

   472                         << "\texpected capabilities =" << capabilities

   473                         << "actual capabilities =" << securityCapabilities;

   474             return false;

   475         }

   476 

   477         for (int i = 0; i < securityCapabilities.count(); ++i) {

   478             if (securityCapabilities[i] != capabilities[i]) {

   479                 qWarning() << "Capability mismatch: expected =" << capabilities[i]

   480                             << " actual =" << securityCapabilities[i];

   481                 return false;

   482             }

   483         }

   484     }

   485 

   486     if (!filePath.isEmpty()) {

   487         if (interface.attribute(QServiceInterfaceDescriptor::Location).toString() != filePath) {

   488             qWarning() << "File path mismatch: expected =" << filePath

   489                 << " actual =" << interface.attribute(QServiceInterfaceDescriptor::Location).toString();

   490             return false;

   491         }

   492     }

   493     if (!serviceDescription.isEmpty()) {

   494         if (interface.attribute(QServiceInterfaceDescriptor::ServiceDescription).toString() != serviceDescription) {

   495             qWarning() << "Service Description mismatch: expected =" << serviceDescription

   496                         << " actual=" << interface.attribute(QServiceInterfaceDescriptor::ServiceDescription).toString();

   497             return false;

   498         }

   499     }

   500     if (!interfaceDescription.isEmpty()) {

   501         if (interface.attribute(QServiceInterfaceDescriptor::InterfaceDescription).toString() != interfaceDescription) {

   502             qWarning() << "Interface Description mismatch: expected =" << interfaceDescription

   503                         << " actual =" << interface.attribute(QServiceInterfaceDescriptor::InterfaceDescription).toString();

   504             return false;

   505         }

   506 

   507     }

   508     return true;

   509 }

   510 #ifdef Q_OS_UNIX

   511 void tst_DatabaseManager::permissions()

   512 {

   513     ServiceMetaDataResults results;

   514     //try create a user scope database with no permissions

   515     //to create the directory needed for the user db

   516     QString userDir =  QSfwTestUtil::userDirectory();

   517     QString systemDir = QSfwTestUtil::systemDirectory();

   518 

   519     QDir::root().mkpath(userDir);

   520     QDir::root().mkpath(systemDir);

   521 

   522     QFile::Permissions userPermsSet = QFile::permissions(userDir);

   523     modifyPermissionSet(userPermsSet, ~QFile::ExeOwner);

   524     QVERIFY(QFile::setPermissions(userDir, userPermsSet));

   525 

   526     m_testdir = QDir(TESTDATA_DIR "/testdata");

   527     ServiceMetaData parser("");

   528     parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceAcme.xml")));

   529     QVERIFY(parser.extractMetadata());

   530     m_dbm = new DatabaseManager;

   531     results = parser.parseResults();

   532     QVERIFY(!m_dbm->registerService(results, DatabaseManager::UserScope));

   533     QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);

   534 

   535     //try to create a system scope database with no permission to

   536     //create the directory needed for the system db

   537     QFile::Permissions systemPermsSet = QFile::permissions(systemDir);

   538     modifyPermissionSet(systemPermsSet, ~QFile::ExeOwner);

   539     QVERIFY(QFile::setPermissions(systemDir, systemPermsSet));

   540 

   541     QVERIFY(!m_dbm->registerService(results, DatabaseManager::SystemScope));

   542     QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);

   543 

   544     //restore directory permissions

   545     modifyPermissionSet(userPermsSet, QFile::ExeOwner);

   546     QVERIFY(QFile::setPermissions(userDir, userPermsSet));

   547     modifyPermissionSet(systemPermsSet, QFile::ExeOwner);

   548     QVERIFY(QFile::setPermissions(systemDir, systemPermsSet));

   549 

   550     //try to create a user scope database without sufficient permissions

   551     //for creation of the database file

   552     QDir::root().mkpath(userDir + "/Nokia/");

   553     userPermsSet = QFile::permissions(userDir + "/Nokia/");

   554     modifyPermissionSet(userPermsSet, ~QFile::WriteOwner);

   555     QVERIFY(QFile::setPermissions(userDir + "/Nokia/", userPermsSet));

   556     QVERIFY(!m_dbm->registerService(results, DatabaseManager::UserScope));

   557     QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);

   558 

   559     //restore user directory permissions and create and populate a user database

   560     modifyPermissionSet(userPermsSet, QFile::WriteOwner);

   561     QVERIFY(QFile::setPermissions(userDir + "/Nokia", userPermsSet));

   562     QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

   563     QString userDbFilePath = m_dbm->m_userDb->databasePath();

   564 

   565     //try to access database without read permissions

   566     userPermsSet = QFile::permissions(userDbFilePath);

   567     modifyPermissionSet(userPermsSet, ~QFile::ReadOwner);

   568 

   569     QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));

   570     delete m_dbm;

   571     QServiceFilter filter;

   572     m_dbm = new DatabaseManager;

   573     QList<QServiceInterfaceDescriptor> descriptors;

   574     descriptors= m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   575     QVERIFY(!m_dbm->m_userDb->isOpen());

   576     QVERIFY(!m_dbm->m_systemDb->isOpen());

   577     QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);

   578 

   579     //restore permissions

   580     modifyPermissionSet(userPermsSet, QFile::ReadOwner);

   581     QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));

   582     

   583     //try to access an artificially corrupted user database

   584     QFile userDbFile(userDbFilePath);

   585     QFile acmeFile(m_testdir.absoluteFilePath("ServiceAcme.xml"));

   586     QVERIFY(acmeFile.open(QIODevice::ReadWrite));

   587     QVERIFY(userDbFile.open(QIODevice::ReadWrite));

   588     userDbFile.resize(50);

   589     userDbFile.seek(100);

   590     QVERIFY(userDbFile.write(acmeFile.readAll()) != -1);

   591     userDbFile.close();

   592     acmeFile.close();

   593     descriptors= m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   594     QVERIFY(!m_dbm->m_userDb->isOpen());

   595     QVERIFY(!m_dbm->m_systemDb->isOpen());

   596     QCOMPARE(m_dbm->lastError().code(), DBError::InvalidDatabaseFile);

   597 

   598     //recreate a valid user database

   599     userDbFile.remove();

   600     QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

   601     filter.setServiceName("");

   602     filter.setInterface("");

   603     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   604     QCOMPARE(descriptors.count(), 5);

   605 

   606     //try to register a service in the user db without write permissions

   607     delete m_dbm;

   608     userPermsSet = QFile::permissions(userDbFilePath);

   609     modifyPermissionSet(userPermsSet, ~QFile::WriteOwner);

   610     QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));

   611     m_dbm = new DatabaseManager;

   612     parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceLuthorCorp.xml")));

   613     QVERIFY(parser.extractMetadata());

   614     results = parser.parseResults();

   615     QVERIFY(!m_dbm->registerService(results, DatabaseManager::UserScope));

   616     QCOMPARE(m_dbm->lastError().code(), DBError::NoWritePermissions);

   617     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   618     QCOMPARE(descriptors.count(), 5);

   619 

   620     modifyPermissionSet(userPermsSet, QFile::WriteOwner);

   621     QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));

   622     clean();

   623 }

   624 

   625 void tst_DatabaseManager::onlyUserDbAvailable()

   626 {

   627     QString userNokiaDir =  QSfwTestUtil::userDirectory() + "/Nokia/";

   628     QString systemNokiaDir = QSfwTestUtil::systemDirectory() + "/Nokia/";

   629 

   630     QDir::root().mkpath(userNokiaDir);

   631     QDir::root().mkpath(systemNokiaDir);

   632     QFile::Permissions systemPermsSet = QFile::permissions(systemNokiaDir);

   633     modifyPermissionSet(systemPermsSet, ~QFile::WriteOwner);

   634     QFile::setPermissions(systemNokiaDir, systemPermsSet);

   635 

   636     m_dbm = new DatabaseManager;

   637 

   638     //check that we can register services with the user database

   639     ServiceMetaData parser("");

   640 

   641     QStringList userServiceFiles;

   642     userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"

   643                     << "ServicePrimatech.xml";

   644     foreach (const QString &serviceFile, userServiceFiles) {

   645         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

   646         QVERIFY(parser.extractMetadata());

   647         ServiceMetaDataResults results = parser.parseResults();

   648         QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

   649         QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   650     }

   651 

   652     QVERIFY(m_dbm->m_userDb->isOpen());

   653     QVERIFY(!m_dbm->m_systemDb->isOpen());

   654 

   655     parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceOmni.xml")));

   656     ServiceMetaDataResults results = parser.parseResults();

   657     QVERIFY(!m_dbm->registerService(results, DatabaseManager::SystemScope));

   658     QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);

   659     

   660     QServiceFilter filter;

   661     filter.setServiceName("");

   662     filter.setInterface("");

   663     QList<QServiceInterfaceDescriptor> descriptors;

   664     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   665     QCOMPARE(descriptors.count(), 8);

   666     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   667 

   668     //Use getInterfaces where the database has not already been opened

   669     //( via a previous call to register service)

   670     delete m_dbm;

   671     m_dbm = new DatabaseManager;

   672     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   673     QCOMPARE(descriptors.count(), 8);

   674     QVERIFY(m_dbm->m_userDb->isOpen());

   675     QVERIFY(!m_dbm->m_systemDb->isOpen());

   676     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   677 

   678     //Use getServiceNames where the database has not already been opened

   679     delete m_dbm;

   680     m_dbm = new DatabaseManager;

   681     QStringList serviceNames;

   682     serviceNames = m_dbm->getServiceNames("", DatabaseManager::UserScope);

   683     QCOMPARE(serviceNames.count(), 3);

   684     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   685 

   686     //Use defaultService where database has not already been opened

   687     delete m_dbm;

   688     m_dbm = new DatabaseManager;

   689     QServiceInterfaceDescriptor descriptor;

   690     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   691             DatabaseManager::UserScope);

   692     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   693                             "LuthorCorp", 1, 2));

   694     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   695     QVERIFY(m_dbm->m_userDb->isOpen());

   696     QVERIFY(!m_dbm->m_systemDb->isOpen());

   697 

   698     //Use setInterfaceDefault(servicename, interfacename, scope)

   699     delete m_dbm;

   700     m_dbm = new DatabaseManager;

   701     QVERIFY(m_dbm->setInterfaceDefault("Primatech", "com.omni.device.accelerometer",

   702                         DatabaseManager::UserScope));

   703     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   704     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   705                                                 DatabaseManager::UserScope);

   706     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   707                                 "Primatech", 1, 4));

   708     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   709 

   710     QVERIFY(!m_dbm->setInterfaceDefault("Primatech", "com.omni.device.accelerometer",

   711                                 DatabaseManager::SystemScope));

   712     QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);

   713 

   714     //Use setInterfaceDefault(descriptor, scope)

   715     filter.setServiceName("Primatech");

   716     filter.setInterface("com.omni.device.accelerometer", "1.2",

   717                                         QServiceFilter::ExactVersionMatch);

   718     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   719     QCOMPARE(descriptors.count(), 1);

   720     QVERIFY(compareDescriptor(descriptors[0], "com.omni.device.accelerometer",

   721                                 "Primatech", 1,2));

   722     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0],

   723                                             DatabaseManager::UserScope));

   724     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   725     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   726                             DatabaseManager::UserScope);

   727     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   728     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   729                                 "Primatech", 1,2));

   730     QVERIFY(!m_dbm->setInterfaceDefault(descriptor, DatabaseManager::SystemScope));

   731     QCOMPARE(m_dbm->lastError().code(), DBError::InvalidDescriptorScope);

   732 

   733     //Use unregisterService()

   734     delete m_dbm;

   735     m_dbm = new DatabaseManager;

   736     QVERIFY(m_dbm->unregisterService("primatech", DatabaseManager::UserScope));

   737     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   738     filter.setServiceName("Primatech");

   739     filter.setInterface("");

   740     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   741     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   742     QCOMPARE(descriptors.count(),0);

   743 

   744     QVERIFY(!m_dbm->unregisterService("primatech", DatabaseManager::SystemScope));

   745     QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);

   746 

   747     //restore permissions so we can clean up the test directories

   748     modifyPermissionSet(systemPermsSet, QFile::WriteOwner);

   749     QFile::setPermissions(systemNokiaDir, systemPermsSet);

   750     clean();

   751 }

   752 

   753 void tst_DatabaseManager::defaultServiceCornerCases()

   754 {

   755     m_dbm = new DatabaseManager;

   756     ServiceMetaData parser("");

   757 

   758     QStringList userServiceFiles;

   759     userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"

   760                     << "ServicePrimatech.xml"

   761                     << "ServiceDharma_Swan.xml"

   762                     << "ServiceDharma_Pearl.xml"

   763                     << "ServiceDharma_Flame.xml"

   764                     << "ServiceDecepticon.xml";

   765 

   766     foreach (const QString &serviceFile, userServiceFiles) {

   767         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

   768         QVERIFY(parser.extractMetadata());

   769         ServiceMetaDataResults results = parser.parseResults();

   770         QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

   771     }

   772 

   773     QStringList systemServiceFiles;

   774     systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"

   775                         << "ServiceDharma_Hydra.xml"

   776                         << "ServiceDharma_Orchid.xml"

   777                         << "ServiceAutobot.xml";

   778     foreach (const QString &serviceFile, systemServiceFiles) {

   779         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

   780         QVERIFY(parser.extractMetadata());

   781         ServiceMetaDataResults results = parser.parseResults();

   782         QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));

   783     }

   784 

   785     // == set a system service interface implementation as a default at user scope then

   786     //    delete the system service and observe whether a new default

   787     //    has been chosen ==

   788     m_dbm->setInterfaceDefault("DharmaInitiative", "com.dharma.electro.discharge",

   789                                 DatabaseManager::UserScope);

   790     QServiceInterfaceDescriptor descriptor =

   791                 m_dbm->interfaceDefault("com.dharma.electro.discharge",

   792                                                 DatabaseManager::UserScope);

   793     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

   794                                 "DharmaInitiative", 42, 0));

   795     QVERIFY(descriptor.scope() == QService::SystemScope);

   796     QVERIFY(m_dbm->unregisterService("DharmaInitiative", DatabaseManager::SystemScope));

   797     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

   798                                                 DatabaseManager::UserScope);

   799     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

   800                                 "DharmaInitiative", 16, 0));

   801     //  check again because there was a bug where the default service

   802     //  was correctly returned the first time but not the second

   803     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

   804                                                 DatabaseManager::UserScope);

   805     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

   806                                 "DharmaInitiative", 16, 0));

   807 

   808     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   809 

   810     // == set a system service interface as a default at user scope,

   811     //    remove availability to system db and confirm default cannot be found

   812     //    for that interface.  Then restore the system db and confirm

   813     //    that a default can indeed be found. ==

   814     QVERIFY(m_dbm->setInterfaceDefault("WayneEnt", "com.omni.device.accelerometer",

   815                                         DatabaseManager::UserScope));

   816     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   817                                         DatabaseManager::UserScope);

   818     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   819                                     "WayneEnt", 2, 0));

   820     QString systemDbFilePath = m_dbm->m_systemDb->databasePath();

   821     QFile::Permissions systemPermsSet = QFile::permissions(systemDbFilePath);

   822     modifyPermissionSet(systemPermsSet, ~QFile::ReadOwner);

   823     QFile::setPermissions(systemDbFilePath, systemPermsSet);

   824 

   825     delete m_dbm;

   826     m_dbm = new DatabaseManager;

   827     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   828                                                 DatabaseManager::UserScope);

   829     QVERIFY(m_dbm->m_userDb->isOpen());

   830     QVERIFY(!m_dbm->m_systemDb->isOpen());

   831     QVERIFY(!descriptor.isValid());

   832     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   833 

   834     modifyPermissionSet(systemPermsSet, QFile::ReadOwner);

   835     QFile::setPermissions(systemDbFilePath, systemPermsSet);

   836     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   837                                                 DatabaseManager::UserScope);

   838     QVERIFY(m_dbm->m_systemDb->isOpen());

   839     QVERIFY(descriptor.isValid());

   840     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   841     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   842                                     "WayneEnt", 2, 0));

   843 

   844     //== set a system service interface as a user scope default,

   845     //   delete the service from the system scope database,

   846     //   ensure that when the default interface is queried

   847     //   it no longer exists ==

   848     m_dbm->setInterfaceDefault("omni", "com.omni.device.lights", //(will set an entry in the

   849                                 DatabaseManager::UserScope);   //defaults table of the user db database)

   850     descriptor = m_dbm->interfaceDefault("com.omni.device.lights",

   851                                         DatabaseManager::UserScope);

   852     QVERIFY(compareDescriptor(descriptor, "com.omni.device.lights",

   853                                 "omni", 9, 0));

   854     QVERIFY(m_dbm->unregisterService("omni", DatabaseManager::SystemScope));

   855     descriptor = m_dbm->interfaceDefault("com.omni.device.lights",

   856                                             DatabaseManager::UserScope);

   857     QVERIFY(!descriptor.isValid());

   858     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   859     clean();

   860     //Reinitialise the database

   861     m_dbm = new DatabaseManager;

   862 

   863     userServiceFiles.clear();

   864     userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"

   865                     << "ServicePrimatech.xml"

   866                     << "ServiceDharma_Swan.xml"

   867                     << "ServiceDecepticon.xml";

   868 

   869     foreach (const QString &serviceFile, userServiceFiles) {

   870         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

   871         QVERIFY(parser.extractMetadata());

   872         ServiceMetaDataResults results = parser.parseResults();

   873         QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

   874     }

   875     systemServiceFiles.clear();

   876     systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"

   877                         << "ServiceDharma_Hydra.xml"

   878                         << "ServiceDharma_Orchid.xml"

   879                         << "ServiceAutobot.xml";

   880     foreach (const QString &serviceFile, systemServiceFiles) {

   881         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

   882         QVERIFY(parser.extractMetadata());

   883         ServiceMetaDataResults results = parser.parseResults();

   884         QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));

   885     }

   886 

   887     //== Set a couple of external defaults in the user scope database,

   888     //   -remove the service that provides these defaults at the system scope.

   889     //    this will leave "hanging" default links in the user scope database

   890     //   -also set one default which will not be a hanging link

   891     //   -recreate the database manager and run getServiceNames so it will

   892     //    connect to both system and user scope databases.

   893     //   -verify that the hanging defaults links have been appropriately removed

   894     //    or reset to a new default interface implementation

   895     //   -also verify that the non-hanging link still exists ==

   896     QServiceFilter filter;

   897     filter.setServiceName("DharmaInitiative");

   898     filter.setInterface("com.dharma.electro.discharge");

   899     QList<QServiceInterfaceDescriptor> descriptors;

   900     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

   901     QVERIFY(descriptors.count() > 0);

   902     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));

   903 

   904     filter.setServiceName("DharmaInitiative");

   905     filter.setInterface("com.dharma.wheel");

   906     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

   907     QVERIFY(descriptors.count() > 0);

   908     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));

   909 

   910     filter.setServiceName("WayneEnt");

   911     filter.setInterface("com.omni.device.accelerometer");

   912     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

   913     QCOMPARE(descriptors.count(), 1);

   914     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));

   915 

   916     QVERIFY(m_dbm->unregisterService("DharmaInitiative", DatabaseManager::SystemScope));

   917     QList<QPair<QString, QString> > externalDefaultsInfo = m_dbm->m_userDb->externalDefaultsInfo();

   918     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   919     QCOMPARE(externalDefaultsInfo.length(), 3);

   920 

   921     delete m_dbm;

   922 

   923     m_dbm = new DatabaseManager;

   924     m_dbm->getServiceNames("", DatabaseManager::UserScope);

   925     QCOMPARE(m_dbm->m_userDb->externalDefaultsInfo().count(), 1);

   926     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

   927                                         DatabaseManager::UserScope);

   928     QVERIFY(compareDescriptor(descriptor,"com.dharma.electro.discharge",

   929                             "DharmaInitiative", 4,0));

   930     descriptor = m_dbm->interfaceDefault("com.dharma.wheel",

   931                                         DatabaseManager::UserScope);

   932     QVERIFY(!descriptor.isValid());

   933     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   934 

   935     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   936                                             DatabaseManager::UserScope);

   937     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   938                             "WayneEnt", 2,0));

   939 

   940     // == set a system service interface as a default at user scope

   941     //        -remove the availability of the system db and confirm the default

   942     //         cannot be found

   943     //        -set a new default

   944     //        -restore availability of the system db and confirm the default

   945     //         is still the new default

   946     filter.setServiceName("omni");

   947     filter.setInterface("com.omni.device.accelerometer");

   948     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   949     QCOMPARE(descriptors.count(), 1);

   950     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));

   951     delete m_dbm;

   952 

   953     systemPermsSet = QFile::permissions(systemDbFilePath);

   954     modifyPermissionSet(systemPermsSet, ~QFile::ReadOwner);

   955     QFile::setPermissions(systemDbFilePath, systemPermsSet);

   956 

   957     m_dbm = new DatabaseManager;

   958     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   959                                                 DatabaseManager::UserScope);

   960     QVERIFY(!descriptor.isValid());

   961     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   962 

   963     filter.setServiceName("LuthorCorp");

   964     filter.setInterface("com.omni.device.accelerometer");

   965     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

   966     QCOMPARE(descriptors.count(), 1);

   967     QVERIFY(m_dbm->m_userDb->isOpen());

   968     QVERIFY(!m_dbm->m_systemDb->isOpen());

   969     QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));

   970     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   971                                         DatabaseManager::UserScope);

   972     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

   973     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   974                                 "LuthorCorp", 1,2));

   975     modifyPermissionSet(systemPermsSet, QFile::ReadOwner);

   976     QFile::setPermissions(systemDbFilePath, systemPermsSet);

   977     m_dbm->getServiceNames("", DatabaseManager::UserScope);//this call is just to open the system db

   978     QVERIFY(m_dbm->m_systemDb->isOpen());

   979 

   980     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

   981                                             DatabaseManager::UserScope);

   982     QVERIFY(descriptor.isValid());

   983     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

   984                                 "LuthorCorp", 1,2));

   985 

   986     // == Try set a descriptor as a default but the descriptor is invalid

   987     //    because the service it belongs to has been removed ==

   988     descriptor = m_dbm->interfaceDefault("com.cybertron.transform",

   989                                          DatabaseManager::SystemScope);

   990     QVERIFY(compareDescriptor(descriptor, "com.cybertron.transform",

   991                                 "Autobot", 2, 7));

   992     QVERIFY(m_dbm->unregisterService("Autobot",

   993                             DatabaseManager::SystemScope));

   994     QVERIFY(!m_dbm->setInterfaceDefault(descriptor, DatabaseManager::UserScope));

   995     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   996 

   997     QVERIFY(!m_dbm->setInterfaceDefault(descriptor, DatabaseManager::SystemScope));

   998     QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);

   999 

  1000     clean();

  1001 }

  1002 #endif

  1003 

  1004 void tst_DatabaseManager::nonWritableSystemDb()

  1005 {

  1006     m_dbm = new DatabaseManager;

  1007     ServiceMetaData parser("");

  1008 

  1009     // Setup Initial user and system databases

  1010     QStringList userServiceFiles;

  1011     userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"

  1012                         << "ServicePrimatech.xml";

  1013     foreach (const QString &serviceFile, userServiceFiles) {

  1014         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

  1015         QVERIFY(parser.extractMetadata());

  1016         ServiceMetaDataResults results = parser.parseResults();

  1017         QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

  1018     }

  1019 

  1020     QStringList systemServiceFiles;

  1021     systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"

  1022                         << "ServiceDharma_Orchid.xml"

  1023                         << "ServiceDharma_Hydra.xml";

  1024     foreach (const QString &serviceFile, systemServiceFiles) {

  1025         parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));

  1026         QVERIFY(parser.extractMetadata());

  1027         ServiceMetaDataResults results = parser.parseResults();

  1028         QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));

  1029     }

  1030 

  1031     //make system database non-writable

  1032     QString systemDbFilePath = m_dbm->m_systemDb->databasePath();

  1033     QFile::Permissions systemPermsSet = QFile::permissions(systemDbFilePath);

  1034     modifyPermissionSet(systemPermsSet, ~QFile::WriteOwner);

  1035     QFile::setPermissions(systemDbFilePath, systemPermsSet);

  1036 

  1037     //== test registration() ==

  1038     delete m_dbm;

  1039     m_dbm = new DatabaseManager;

  1040     parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceDharma_Swan.xml")));

  1041     QVERIFY(parser.extractMetadata());

  1042     ServiceMetaDataResults results = parser.parseResults();

  1043     QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));

  1044     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

  1045 

  1046     parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceAutobot.xml")));

  1047     QVERIFY(parser.extractMetadata());

  1048     results = parser.parseResults();

  1049     QVERIFY(!m_dbm->registerService(results, DatabaseManager::SystemScope));

  1050     QCOMPARE(m_dbm->lastError().code(), DBError::NoWritePermissions);

  1051 

  1052     //== test getInterfaces() ==

  1053     delete m_dbm;

  1054     m_dbm = new DatabaseManager;

  1055     QList<QServiceInterfaceDescriptor> descriptors;

  1056     QServiceFilter filter;

  1057     filter.setServiceName("");

  1058     filter.setInterface("");

  1059     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

  1060     QCOMPARE(descriptors.count(), 18);

  1061 

  1062     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

  1063     QCOMPARE(descriptors.count(), 9);

  1064 

  1065     //  try a more restrictive filter with getInterfaces

  1066     filter.setServiceName("");

  1067     filter.setInterface("com.dharma.electro.discharge", "4.0");

  1068     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);

  1069     QCOMPARE(descriptors.count(), 4);

  1070 

  1071     descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);

  1072     QCOMPARE(descriptors.count(), 3);

  1073 

  1074     // ==test getServiceName() ==

  1075     delete m_dbm;

  1076     m_dbm = new DatabaseManager;

  1077     QStringList expectedNames;

  1078     expectedNames << "LuthorCorp" << "Primatech" << "WayneEnt" << "omni";

  1079     QStringList serviceNames = m_dbm->getServiceNames("com.omni.device.accelerometer",

  1080                                             DatabaseManager::UserScope);

  1081     foreach(const QString expectedName, expectedNames)

  1082         QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));

  1083     QCOMPARE(serviceNames.count(), expectedNames.count());

  1084 

  1085     expectedNames.clear();

  1086     expectedNames << "WayneEnt" << "omni";

  1087     serviceNames = m_dbm->getServiceNames("com.omni.device.accelerometer",

  1088                                             DatabaseManager::SystemScope);

  1089     foreach(const QString expectedName, expectedNames)

  1090         QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));

  1091     QCOMPARE(serviceNames.count(), expectedNames.count());

  1092 

  1093     //== test interfaceDefault() ==

  1094     delete m_dbm;

  1095     m_dbm = new DatabaseManager;

  1096     QServiceInterfaceDescriptor descriptor;

  1097     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

  1098                                             DatabaseManager::UserScope);

  1099     QStringList capabilities;

  1100     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

  1101                             "DharmaInitiative", 4, 0, capabilities, "C:/island/swan.dll"));

  1102 

  1103     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

  1104                                             DatabaseManager::SystemScope);

  1105     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

  1106                             "DharmaInitiative", 4, 0, capabilities, "C:/island/orchid.dll"));

  1107     //test setInterfaceDefault(service, interface, scope)

  1108     delete m_dbm;

  1109     m_dbm = new DatabaseManager;

  1110     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

  1111                                                 DatabaseManager::UserScope);

  1112     QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",

  1113                                 "LuthorCorp", 1,2));

  1114     QVERIFY(m_dbm->setInterfaceDefault("Primatech", "com.omni.device.accelerometer",

  1115                                 DatabaseManager::UserScope));

  1116     descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",

  1117                                                 DatabaseManager::UserScope);

  1118 

  1119     //  try setting descriptor that originates from the system db

  1120     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

  1121                                             DatabaseManager::UserScope);

  1122     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

  1123                                     "DharmaInitiative", 4, 0));

  1124     QVERIFY(m_dbm->setInterfaceDefault("DharmaInitiative", "com.dhARMa.electro.discharge",

  1125                                     DatabaseManager::UserScope));

  1126     QCOMPARE(m_dbm->lastError().code(), DBError::NoError);

  1127     descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",

  1128                                             DatabaseManager::UserScope);

  1129     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",

  1130                                     "DharmaInitiative", 42, 0));

  1131 

  1132     //  try setting a default at systems scope (this should fail)

  1133     descriptor = m_dbm->interfaceDefault("com.dharma.electro.Discharge",

  1134                                             DatabaseManager::SystemScope);

  1135     QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",