Changeset 368


Ignore:
Timestamp:
Apr 26, 2016, 7:28:15 PM (5 years ago)
Author:
Joachim Langenbach
Message:
  • Fixed and tested Database and DB User creation by EDBSettings widget
  • Added CMAKE Variables, to allow the specification of Database Test server and admin user with password
Location:
trunk
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/CMakeLists.txt

    r357 r368  
    11######################
    22#
    3 #    Copyright (C) 2010 - 2015 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
     3#    Copyright (C) 2010 - 2016 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
    44#
    55#    This library is free software; you can redistribute it and/or
     
    106106SET(WITH_API_DOCS_WANTED ${WITH_API_DOCS})
    107107SET(WITH_EXAMPLES_WANTED ${WITH_EXAMPLES})
     108
     109IF(BUILD_TESTING)
     110        SET(DATABASE_TEST_HOST "192.178.2.1" CACHE STRING "Host running the MySQL server to run the database tests")
     111        SET(DATABASE_TEST_ADMIN_USER "test" CACHE STRING "User to connect to the MySQL server to run the database tests")
     112        SET(DATABASE_TEST_ADMIN_PASSWORD "testadmin" CACHE STRING "Password to connect to the MySQL server to run the database tests")
     113ENDIF(BUILD_TESTING)
    108114
    109115MARK_AS_ADVANCED(COMPATIBLE_WITH_NON_KDE WITH_API_DOCS)
     
    434440MESSAGE("  BUILD_DEV:                               ${BUILD_DEV_WANTED}         ${BUILD_DEV}")
    435441MESSAGE("  BUILD_TESTING:                           ${BUILD_TESTING_WANTED}             ${BUILD_TESTING}")
     442MESSAGE("    DATABASE_TEST_HOST:                    ${DATABASE_TEST_HOST}")
     443MESSAGE("    DATABASE_TEST_USER:                    ${DATABASE_TEST_ADMIN_USER}")
     444MESSAGE("    DATABASE_TEST_PASSWORD:                ${DATABASE_TEST_ADMIN_PASSWORD}")
    436445MESSAGE("  BINDINGS_KDE:                            ${BINDINGS_KDE_WANTED}              ${BINDINGS_KDE}")
    437446MESSAGE("  BINDINGS_QT4:                            ${BINDINGS_QT4_WANTED}              ${BINDINGS_QT4}")
  • trunk/src/lib/core/edbsettings.cpp

    r337 r368  
    11/*
    2     Copyright (C) 2010 - 2015 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
     2    Copyright (C) 2010 - 2016 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
    33
    44    This library is free software; you can redistribute it and/or
     
    5151{
    5252        QString msg;
    53   if ( !saveSettings(msg) )
    54     return false;
    55 
    56   if ( !ESqlLogin::checkDBSettings() ) {
    57     emit error ( tr ( "The database settings are faulty!" ) );
    58     return false;
    59   }
    60 
     53        if ( !saveSettingsOnly(msg) )
     54                return false;
     55
     56        if ( !ESqlLogin::checkDBSettings() ) {
     57                emit error ( tr ( "The database settings are faulty!" ) );
     58                return false;
     59        }
     60 
    6161        // if create user or create database is selected,
    6262        // we must use an admin connection
     
    8484                }
    8585                QSqlQuery query(db);
    86                 // first create user if needed
     86               
     87                QString host = "%";
     88                // create user if needed
    8789                if(ui->createUserBox->isChecked()){
    88                         QString host = "%";
    8990                        if(userName.isEmpty()){
    9091                                emit error(tr("Empty Username is not allowed."));
     
    103104                        queryNotReuseable.bindValue(":User", userName);
    104105                        if(!queryNotReuseable.exec()){
    105                                 emit error(tr("Could not check wether user exist."));
     106                                QString dbError;
     107                                if(queryNotReuseable.lastError().isValid())
     108                                        dbError = queryNotReuseable.lastError().text();
     109                                emit error(tr("Could not check wether user exist (%1)").arg(dbError));
    106110                                db.close();
    107111                                return false;
     
    114118                                query.addBindValue(password);
    115119                                if(!query.exec()){
    116                                         emit error(tr("Could not change password."));
     120                                        QString dbError;
     121                                        if(query.lastError().isValid())
     122                                                dbError = query.lastError().text();
     123                                        emit error(tr("Could not change password (%1)").arg(dbError));
    117124                                        return false;
    118125                                }
     
    125132                                query.addBindValue(password);
    126133                                if(!query.exec()){
    127                                         emit error(tr("Could not create user."));
     134                                        QString dbError;
     135                                        if(query.lastError().isValid())
     136                                                dbError = query.lastError().text();
     137                                        emit error(tr("Could not create user (%1)").arg(dbError));
    128138                                        return false;
    129139                                }
     140                                // add extra rule for localhost needed, because the default
     141                                // mysql.user table may contain an entry ''@'localhost' which superseeds 'USER'@'%'.
     142                                query.prepare("CREATE USER ?@? IDENTIFIED BY ?");
     143                                query.addBindValue(userName);
     144                                query.addBindValue("localhost");
     145                                query.addBindValue(password);
     146                                if(!query.exec()){
     147                                        QString dbError;
     148                                        if(query.lastError().isValid())
     149                                                dbError = query.lastError().text();
     150                                        emit error(tr("Could not create user for localhost (%1)").arg(dbError));
     151                                        return false;
     152                                }
     153                        }
     154                }
     155               
     156                // create the database first, if needed
     157                if(ui->createDBEdit->isChecked()){
     158                        // check wether database already exists
     159                        if(!query.exec(QString("CREATE DATABASE IF NOT EXISTS %1").arg(dbName))){
     160                                QString dbError;
     161                                if(query.lastError().isValid())
     162                                        dbError = query.lastError().text();
     163                                emit error(tr("Could not create database (%1)").arg(dbError));
     164                                return false;
    130165                        }
    131166                        // grant privileges
    132                         query.prepare("GRANT ALL ON ?.* TO ?@?");
    133                         query.addBindValue(dbName);
     167                        query.prepare("GRANT ALL PRIVILEGES ON "+ dbName +".* TO ?@?");
    134168                        query.addBindValue(userName);
    135169                        query.addBindValue(host);
    136170                        if(!query.exec()){
    137                                 emit error(tr("Could not grant privileges to chosen database."));
    138                                 return false;
    139                         }
    140                         if(!query.exec("FLUSH PRIVILEGES")){
    141                                 emit error(tr("Could not reload privileges."));
    142                                 return false;
    143                         }
    144                 }
    145 
    146                 // create database
    147                 if(ui->createDBEdit->isChecked()){
    148                         // check wether database already exists
    149                         if(!query.exec(QString("CREATE DATABASE IF NOT EXISTS %1").arg(dbName))){
    150                                 emit error(tr("Could not create database."));
    151                                 return false;
    152                         }
    153                 }
     171                                QString dbError;
     172                                if(query.lastError().isValid())
     173                                        dbError = query.lastError().text();
     174                                emit error(tr("Could not grant privileges to chosen database (%1)").arg(dbError));
     175                                return false;
     176                        }
     177                }
     178
     179                if(!query.exec("FLUSH PRIVILEGES")){
     180                        QString dbError;
     181                        if(query.lastError().isValid())
     182                                dbError = query.lastError().text();
     183                        emit error(tr("Could not reload privileges (%1)").arg(dbError));
     184                        return false;
     185                }
     186
    154187                db.close();
    155188        }
    156189
    157   ESqlLogin sqlLogin(true, this);
     190        ESqlLogin sqlLogin(true, this);
    158191        sqlLogin.loadAndCheckSettings(userName, "", "", "", password);
    159192        connectByPass ( &sqlLogin );
    160193
    161194        bool result = false;
    162   if ( sqlLogin.login() == ESqlLogin::LoggedIn )
     195        if ( sqlLogin.login() == ESqlLogin::LoggedIn )
    163196                result =  true;
    164197
    165   return result;
     198        return result;
    166199}
    167200
    168201bool EDBSettings::saveSettings (QString& error)
    169202{
    170         if(!ui->eDBSettingsWidget->saveSettings(error))
     203        if(!saveSettingsOnly(error))
    171204                return false;
    172205
    173206        emit reloadSettingsRequest();
    174   return true;
     207        return true;
    175208}
    176209
     
    179212        ESqlLogin sqlLogin(true, this);
    180213        sqlLogin.loadAndCheckSettings();
    181         connectByPass ( &sqlLogin );
    182   sqlLogin.login();
     214        connectByPass ( &sqlLogin );
     215        sqlLogin.login();
    183216        EWidget::reloadSettings();
    184217}
     218
     219bool EDBSettings::saveSettingsOnly(QString& error)
     220{
     221        return ui->eDBSettingsWidget->saveSettings(error);
     222}
  • trunk/src/lib/core/edbsettings.h

    r231 r368  
    11/*
    2     Copyright (C) 2010 - 2012 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
     2    Copyright (C) 2010 - 2016 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
    33
    44    This library is free software; you can redistribute it and/or
     
    4242{
    4343        Q_OBJECT
    44   public:
     44        public:
    4545                /**
    4646                        * You can specify which database drivers are displayed at the dropdown box with
     
    5050                        */
    5151                EDBSettings ( QStringList drivers = QStringList(), ESetupWizardObject *newObject = 0, QWidget *parent = 0, Qt::WindowFlags fl = 0 );
    52     ~EDBSettings();
     52                ~EDBSettings();
    5353
    5454  public slots:
     
    6060                        */
    6161    bool finish();
     62        /**
     63         * @brief Saves the settings with saveSettingsOnly() and emits reloadSettings signal
     64         */
    6265    bool saveSettings(QString& error);
    6366                void reloadSettings();
    6467
    6568        private:
     69                /**
     70                 * @brief Only saves the settings, does not emit reloadSettings signal
     71                 */
     72                bool saveSettingsOnly(QString& error);
     73
    6674                Ui::EDBSettings *ui;
    6775};
  • trunk/src/lib/core/esqllogin.cpp

    r337 r368  
    11/*
    2                 Copyright (C) 2013 - 2015 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
     2                Copyright (C) 2013 - 2016 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
    33
    44                This library is free software; you can redistribute it and/or
     
    126126        // gui doesn't metter here, therefore it is disabled here
    127127        ESqlLogin login(false);
    128         login.loadAndCheckSettings();
    129         return login.checkDBSettingsPrivate();
     128        return login.loadAndCheckSettings();
    130129}
    131130
  • trunk/src/tests/core/sqltests/CMakeLists.txt

    r337 r368  
    11######################
    22#
    3 #    Copyright (C) 2010 - 2015 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
     3#    Copyright (C) 2010 - 2016 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
    44#
    55#    This library is free software; you can redistribute it and/or
     
    4242
    4343ADD_DEFINITIONS(${QT_DEFINITIONS})
     44
     45CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/dbtestsettings.h.in ${CMAKE_CURRENT_BINARY_DIR}/dbtestsettings.h)
    4446
    4547#######################
  • trunk/src/tests/core/sqltests/edbsettingstest.cpp

    r365 r368  
    11/*
    22 *
    3  *     Copyright (C) 2015 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
     3 *     Copyright (C) 2015 - 2016 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
    44 *
    55 *     This library is free software; you can redistribute it and/or
     
    2323#include "moc_edbsettingstest.cpp"
    2424
     25#include "dbtestsettings.h"
     26
    2527#include <edbsettings.h>
    2628#include <edbsettingswidget.h>
     
    3638#include <QGroupBox>
    3739#include <QSqlQuery>
     40#include <QSqlError>
    3841#include <QSignalSpy>
    3942
     
    5861        QCOMPARE(settings.allKeys().size(), 0);
    5962
    60         username = "test";
    61         password = "test";
    62         host = "192.168.2.1";
    63        
    64         usernameAdmin = "testadmin";
    65         passwordAdmin = "test";
     63        databasePrefix = "libengsastests";
     64        username = "libengsastest";
     65        password = "libengsastest";
     66        host = QString(DATABASE_TEST_HOST);
    6667       
    6768        ESqlDatabase db = ESqlDatabase::addDatabase("QMYSQL", "testInitTestCaseConnection");
    6869        db.setHostName(host);
    6970        db.setPort(3306);
     71       
     72        usernameAdmin = QString(DATABASE_TEST_ADMIN_USER);
     73        passwordAdmin = QString(DATABASE_TEST_ADMIN_PASSWORD);
     74        adminDatabaeConnectionName = "testAdminConnection";
     75        ESqlDatabase adminDatabase = ESqlDatabase::addDatabase("QMYSQL", adminDatabaeConnectionName);
     76        adminDatabase.setHostName(host);
     77        adminDatabase.setUserName(usernameAdmin);
     78        adminDatabase.setPassword(passwordAdmin);
    7079       
    7180        // test if server is reachable, because QSqlDatabase has a huge timeout
     
    7685        if(!socket->waitForConnected(2000)){
    7786#if QT_VERSION >= 0x050000
    78         QSKIP("This test requires a database connection");
    79 #else
    80         QSKIP("This test requires a database connection", SkipAll);
     87        QSKIP("This test requires a database connection. Please check DATABAE_TEST_* VARIABLES in CMake.");
     88#else
     89        QSKIP("This test requires a database connection. Please check DATABAE_TEST_* VARIABLES in CMake.", SkipAll);
    8190#endif
    8291        }
     
    140149void EDBSettingsTest::connectToExistingDatabase()
    141150{
    142         QString database = "test_"+ QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");
     151        QString database = databasePrefix +"_"+ QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");
    143152       
    144153        ESetupWizardDB setupWizard("Test", NULL);
     
    174183       
    175184
    176         ESqlDatabase adminDatabase = ESqlDatabase::addDatabase("QMYSQL", "testAdminConnection");
    177         adminDatabase.setHostName(host);
    178         adminDatabase.setUserName(username);
    179         adminDatabase.setPassword(password);
    180 
    181         QVERIFY(adminDatabase.open());
    182         QSqlQuery query(adminDatabase);
    183         // create database
    184         bool result = query.exec("CREATE DATABASE "+ database);
    185         if(!result){
    186                 adminDatabase.close();
    187                 QTest::qWarn("Could not create new database");
    188                 QVERIFY(result);
    189         }
     185        setupDatabase(database, username, password);
    190186
    191187        ECloseModalWidgetThread thread;
     
    193189        // the Qt::Key does not matter here, with the press of the selected key, the string is
    194190        // send as key content.
    195         events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "test"));
     191        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, username));
    196192        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, ""));
    197         events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "test"));
     193        events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, password));
    198194        events << ECloseModalWidgetEvent("loginButton", new QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier));
    199195        thread.setEvents(events);
     
    221217
    222218        // cleanup
    223         QVERIFY(adminDatabase.open());
    224         result = query.exec("DROP DATABASE "+ database);
    225         adminDatabase.close();
    226         QVERIFY(result);
     219        cleanupDatabase(database, username);
    227220
    228221        resetSettings();
     
    236229        QEXPECT_FAIL("", "Currently creating databases with unprivileged users is not supported!", Abort);
    237230        QVERIFY(0 == 1);
    238        
    239 /*
    240         QString database = "test_"+ QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");
     231
     232}
     233
     234void EDBSettingsTest::createDatabaseWithPrivilegedUser()
     235{
     236        QString database = databasePrefix +"_admin_"+ QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");
    241237       
    242238        ESetupWizardDB setupWizard("Test", NULL);
     
    260256        QWidget *databaseEdit = eDBSettings->findChild<QWidget*>("databaseEdit");
    261257        QVERIFY(databaseEdit);
    262         QTest::keyClicks(databaseEdit, host);
     258        QTest::keyClicks(databaseEdit, database);
    263259        QTest::keyClick(databaseEdit, Qt::Key_Return);
    264260
     
    272268        QCOMPARE(createUserBox->isChecked(), false);
    273269       
    274         ECloseModalWidgetThread thread;
    275         ECloseModalWidgetEvents events;
    276         // the Qt::Key does not matter here, with the press of the selected key, the string is
    277         // send as key content.
    278         events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "test"));
    279         events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, ""));
    280         events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "test"));
    281         events << ECloseModalWidgetEvent("loginButton", new QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier));
    282         thread.setEvents(events);
    283         thread.start();
    284         if(!thread.waitForStart())
    285                 QSKIP("Could not start thread", SkipSingle);
    286         bool eDBSettingsFinish = eDBSettings->finish();
    287         thread.stopThread();
    288         printErrors(&errorSpy);
    289         QCOMPARE(eDBSettingsFinish, true);
    290         QCOMPARE(errorSpy.count(), 0);
    291         QCOMPARE(EDBSettingsWidget::host(), host);
    292         QCOMPARE(EDBSettingsWidget::database(), database);
    293         QCOMPARE(EDBSettingsWidget::driver(), driver);
    294 
    295         ESqlDatabase createdDatabaseConnection;
    296         QCOMPARE(createdDatabaseConnection.databaseName(), database);
    297         QCOMPARE(createdDatabaseConnection.open(), true);
    298         createdDatabaseConnection.close();
    299         QCOMPARE(createdDatabaseConnection.isOpen(), false);
    300 
    301         // cleanup
    302         ESqlDatabase adminDatabase = ESqlDatabase::addDatabase("QMYSQL", "testAdminConnection");
    303         adminDatabase.setHostName(host);
    304         adminDatabase.setUserName(username);
    305         adminDatabase.setPassword(password);
    306         QVERIFY(adminDatabase.open());
    307         QSqlQuery query(adminDatabase);
    308         QVERIFY(adminDatabase.open());
    309         bool result = query.exec("DROP DATABASE "+ database);
    310         adminDatabase.close();
    311         QVERIFY(result);
    312        
    313         resetSettings();
    314 
    315         // pass a little bit of time, to get a different database name in next test
    316         QTest::qWait(100);
    317 */
    318 }
    319 
    320 void EDBSettingsTest::createDatabaseWithPrivilegedUser()
    321 {
    322         QString database = "testadmin_"+ QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");
    323        
    324         ESetupWizardDB setupWizard("Test", NULL);
    325         QList<ESetupWizardWidget*> widgets = setupWizard.wizardWidgets();
    326         QCOMPARE(widgets.size(), 2);
    327         EDBSettings *eDBSettings = qobject_cast<EDBSettings*>(widgets[0]);
    328         QVERIFY(eDBSettings);
    329         eDBSettings->show();
    330        
    331         QSignalSpy errorSpy(eDBSettings, SIGNAL(error(QString)));
    332        
    333         // select database driver
    334         QString driver = "QMYSQL";
    335         selectDriver(eDBSettings, driver);
    336 
    337         QWidget *hostEdit = eDBSettings->findChild<QWidget*>("hostEdit");
    338         QVERIFY(hostEdit);
    339         QTest::keyClicks(hostEdit, host);
    340         QTest::keyClick(hostEdit, Qt::Key_Return);
    341 
    342         QWidget *databaseEdit = eDBSettings->findChild<QWidget*>("databaseEdit");
    343         QVERIFY(databaseEdit);
    344         QTest::keyClicks(databaseEdit, database);
    345         QTest::keyClick(databaseEdit, Qt::Key_Return);
    346 
    347         QCheckBox *createDBEdit = eDBSettings->findChild<QCheckBox*>("createDBEdit");
    348         QVERIFY(createDBEdit);
    349         createDBEdit->setChecked(true);
    350         QCOMPARE(createDBEdit->isChecked(), true);
    351 
    352         QGroupBox *createUserBox = eDBSettings->findChild<QGroupBox*>("createUserBox");
    353         QVERIFY(createUserBox);
    354         QCOMPARE(createUserBox->isChecked(), false);
     270        setupDatabase(database, username, password, true);
    355271       
    356272        // thread for privileged user login
     
    359275        // the Qt::Key does not matter here, with the press of the selected key, the string is
    360276        // send as key content.
    361         events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "testadmin"));
     277        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, usernameAdmin));
    362278        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, ""));
    363         events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "test"));
     279        events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, passwordAdmin));
    364280        events << ECloseModalWidgetEvent("loginButton", new QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier));
    365281        thread1.setEvents(events);
     
    378294        // the Qt::Key does not matter here, with the press of the selected key, the string is
    379295        // send as key content.
    380         events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "test"));
     296        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, username));
    381297        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, ""));
    382         events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, "test"));
     298        events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, password));
    383299        events << ECloseModalWidgetEvent("loginButton", new QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier));
    384300        thread2.setEvents(events);
     
    408324        QCOMPARE(createdDatabaseConnection.isOpen(), false);
    409325
     326        cleanupDatabase(database, username);
     327       
     328        resetSettings();
     329}
     330
     331void EDBSettingsTest::createDatabaseAndUserWithPrivilegedUser()
     332{
     333        QString database = databasePrefix +"_adminanduser_"+ QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");
     334       
     335        ESetupWizardDB setupWizard("Test", NULL);
     336        QList<ESetupWizardWidget*> widgets = setupWizard.wizardWidgets();
     337        QCOMPARE(widgets.size(), 2);
     338        EDBSettings *eDBSettings = qobject_cast<EDBSettings*>(widgets[0]);
     339        QVERIFY(eDBSettings);
     340        eDBSettings->show();
     341       
     342        QSignalSpy errorSpy(eDBSettings, SIGNAL(error(QString)));
     343       
     344        // select database driver
     345        QString driver = "QMYSQL";
     346        selectDriver(eDBSettings, driver);
     347
     348        QWidget *hostEdit = eDBSettings->findChild<QWidget*>("hostEdit");
     349        QVERIFY(hostEdit);
     350        QTest::keyClicks(hostEdit, host);
     351        QTest::keyClick(hostEdit, Qt::Key_Return);
     352
     353        QWidget *databaseEdit = eDBSettings->findChild<QWidget*>("databaseEdit");
     354        QVERIFY(databaseEdit);
     355        QTest::keyClicks(databaseEdit, database);
     356        QTest::keyClick(databaseEdit, Qt::Key_Return);
     357
     358        QCheckBox *createDBEdit = eDBSettings->findChild<QCheckBox*>("createDBEdit");
     359        QVERIFY(createDBEdit);
     360        createDBEdit->setChecked(true);
     361        QCOMPARE(createDBEdit->isChecked(), true);
     362
     363        QGroupBox *createUserBox = eDBSettings->findChild<QGroupBox*>("createUserBox");
     364        QVERIFY(createUserBox);
     365        createUserBox->setChecked(true);
     366        QCOMPARE(createUserBox->isChecked(), true);
     367       
     368        QWidget *createUserNameEdit = eDBSettings->findChild<QWidget*>("createUserNameEdit");
     369        QVERIFY(createUserNameEdit);
     370        QTest::keyClicks(createUserNameEdit, username);
     371        QTest::keyClick(createUserNameEdit, Qt::Key_Return);
     372       
     373        QWidget *createUserPasswordEdit = eDBSettings->findChild<QWidget*>("createUserPasswordEdit");
     374        QVERIFY(createUserPasswordEdit);
     375        QTest::keyClicks(createUserPasswordEdit, password);
     376        QTest::keyClick(createUserPasswordEdit, Qt::Key_Return);
     377       
     378        // thread for privileged user login
     379        ECloseModalWidgetThread thread1(5000);
     380        ECloseModalWidgetEvents events;
     381        // the Qt::Key does not matter here, with the press of the selected key, the string is
     382        // send as key content.
     383        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, usernameAdmin));
     384        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, ""));
     385        events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, passwordAdmin));
     386        events << ECloseModalWidgetEvent("loginButton", new QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier));
     387        thread1.setEvents(events);
     388        thread1.start();
     389        if(!thread1.waitForStart()){
     390#if QT_VERSION >= 0x050000
     391                QSKIP("Could not start thread1");
     392#else
     393                QSKIP("Could not start thread1", SkipSingle);
     394#endif
     395        }
     396
     397        // thread for unprivileged user login
     398        ECloseModalWidgetThread thread2(10000);
     399        events.clear();
     400        // the Qt::Key does not matter here, with the press of the selected key, the string is
     401        // send as key content.
     402        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, username));
     403        events << ECloseModalWidgetEvent("usernameEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, ""));
     404        events << ECloseModalWidgetEvent("passwordEdit", new QKeyEvent(QEvent::KeyPress, Qt::Key_No, Qt::NoModifier, password));
     405        events << ECloseModalWidgetEvent("loginButton", new QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier));
     406        thread2.setEvents(events);
     407        thread2.start();
     408        if(!thread2.waitForStart()){
     409#if QT_VERSION >= 0x050000
     410                QSKIP("Could not start thread2");
     411#else
     412                QSKIP("Could not start thread2", SkipSingle);
     413#endif
     414        }
     415
     416        bool eDBSettingsFinish = eDBSettings->finish();
     417        thread1.stopThread();
     418        thread2.stopThread();
     419        printErrors(&errorSpy);
     420        QCOMPARE(eDBSettingsFinish, true);
     421        QCOMPARE(errorSpy.count(), 0);
     422        QCOMPARE(EDBSettingsWidget::host(), host);
     423        QCOMPARE(EDBSettingsWidget::database(), database);
     424        QCOMPARE(EDBSettingsWidget::driver(), driver);
     425
     426        ESqlDatabase createdDatabaseConnection = ESqlDatabase::database();
     427        QCOMPARE(createdDatabaseConnection.databaseName(), database);
     428        QCOMPARE(createdDatabaseConnection.open(), true);
     429        createdDatabaseConnection.close();
     430        QCOMPARE(createdDatabaseConnection.isOpen(), false);
     431
    410432        // cleanup
    411         ESqlDatabase adminDatabase = ESqlDatabase::addDatabase("QMYSQL", "testAdminConnection");
    412         adminDatabase.setHostName(host);
    413         adminDatabase.setUserName(usernameAdmin);
    414         adminDatabase.setPassword(passwordAdmin);
    415         QVERIFY(adminDatabase.open());
    416         QSqlQuery query(adminDatabase);
    417         QVERIFY(adminDatabase.open());
    418         bool result = query.exec("DROP DATABASE "+ database);
    419         adminDatabase.close();
    420         QVERIFY(result);
     433        cleanupDatabase(database, username);
    421434       
    422435        resetSettings();
     
    468481}
    469482
     483void EDBSettingsTest::setupDatabase(QString createDatabase, QString createUser, QString userPassword, bool manageUserOnly)
     484{
     485        ESqlDatabase adminDatabase = ESqlDatabase::database(adminDatabaeConnectionName);
     486
     487        QVERIFY(adminDatabase.open());
     488        QSqlQuery query(adminDatabase);
     489        QVERIFY(adminDatabase.open());
     490        // create database
     491        if(!createDatabase.isEmpty() && !manageUserOnly){
     492                bool result = query.exec("CREATE DATABASE "+ createDatabase);
     493                if(!result){
     494                        adminDatabase.close();
     495                        QString dbError;
     496                        if(query.lastError().isValid())
     497                                dbError = query.lastError().text();
     498                        QTest::qWarn("Could not create new database: "+ dbError.toUtf8());
     499                        QVERIFY(result);
     500                }
     501        }
     502        // create new user
     503        if(!createUser.isEmpty() && !userPassword.isEmpty()){
     504                query.prepare("CREATE USER ?@? IDENTIFIED BY ?");
     505                query.addBindValue(createUser);
     506                query.addBindValue(host);
     507                query.addBindValue(userPassword);
     508                if(!query.exec()){
     509                        adminDatabase.close();
     510                        QString dbError;
     511                        if(query.lastError().isValid())
     512                                dbError = query.lastError().text();
     513                        QTest::qWarn("Could not create user: "+ dbError.toUtf8());
     514                        QTest::qWarn("Query: "+ query.lastQuery().toUtf8());
     515                        QVERIFY(false);
     516                }
     517                // grant privileges
     518                query.prepare("GRANT ALL PRIVILEGES ON "+ createDatabase +".* TO ?@?");
     519                query.addBindValue(username);
     520                query.addBindValue(host);
     521                if(!query.exec()){
     522                        adminDatabase.close();
     523                        QString dbError;
     524                        if(query.lastError().isValid())
     525                                dbError = query.lastError().text();
     526                        QTest::qWarn("Could not grant privileges to chosen database: "+ dbError.toUtf8());
     527                        QVERIFY(false);
     528                }
     529               
     530                if(!query.exec("FLUSH PRIVILEGES")){
     531                        QString dbError;
     532                        if(query.lastError().isValid())
     533                                dbError = query.lastError().text();
     534                        QTest::qWarn("Could not reload privileges: "+ dbError.toUtf8());
     535                        QVERIFY(false);
     536                }
     537        }
     538
     539        adminDatabase.close();
     540}
     541
     542void EDBSettingsTest::cleanupDatabase(QString dropDatabase, QString dropUser)
     543{
     544        // cleanup
     545        ESqlDatabase adminDatabase = ESqlDatabase::database(adminDatabaeConnectionName);
     546        QVERIFY(adminDatabase.open());
     547        QSqlQuery query(adminDatabase);
     548        QVERIFY(adminDatabase.open());
     549       
     550        // drop databae
     551        if(!dropDatabase.isEmpty()){
     552                if(!query.exec("DROP DATABASE "+ dropDatabase)){
     553                        adminDatabase.close();
     554                        QString dbError;
     555                        if(query.lastError().isValid())
     556                                dbError = query.lastError().text();
     557                        QTest::qWarn("Could not drop database "+ dropDatabase.toUtf8() +": "+ dbError.toUtf8());
     558                        QVERIFY(false);
     559                }
     560        }
     561       
     562        // Drop user
     563        if(!dropUser.isEmpty()){
     564                // drop user with all of it's hosts
     565                QSqlQuery queryNotReuseable(adminDatabase);
     566                queryNotReuseable.prepare("SELECT User, Host FROM mysql.user WHERE User=:User");
     567                queryNotReuseable.bindValue(":User", dropUser);
     568                if(!queryNotReuseable.exec()){
     569                        adminDatabase.close();
     570                        QString dbError;
     571                        if(queryNotReuseable.lastError().isValid())
     572                                dbError = queryNotReuseable.lastError().text();
     573                        QTest::qWarn("Could not find user hosts for "+ dropUser.toUtf8() +": "+ dbError.toUtf8());
     574                        QVERIFY(false);
     575                }
     576                while(queryNotReuseable.next()){
     577                        query.prepare("DROP USER ?@?");
     578                        query.addBindValue(dropUser);
     579                        query.addBindValue(queryNotReuseable.value(1).toString());
     580                        if(!query.exec()){
     581                                adminDatabase.close();
     582                                QString dbError;
     583                                if(query.lastError().isValid())
     584                                        dbError = query.lastError().text();
     585                                QTest::qWarn("Could not drop user "+ dropUser.toUtf8() +": "+ dbError.toUtf8());
     586                                QVERIFY(false);
     587                        }
     588                }
     589
     590                if(!query.exec("FLUSH PRIVILEGES")){
     591                        QString dbError;
     592                        if(query.lastError().isValid())
     593                                dbError = query.lastError().text();
     594                        QTest::qWarn("Could not reload privileges: "+ dbError.toUtf8());
     595                        QVERIFY(false);
     596                }
     597        }
     598       
     599        adminDatabase.close();
     600}
     601
    470602QTEST_MAIN(EDBSettingsTest)
  • trunk/src/tests/core/sqltests/edbsettingstest.h

    r340 r368  
    11/*
    22 *
    3  *     Copyright (C) 2015 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
     3 *     Copyright (C) 2015 - 2016 EngSaS - Engineering Solutions and Services Langenbach. All rights reserved.
    44 *
    55 *     This library is free software; you can redistribute it and/or
     
    4242                void createDatabaseWithUnprivilegedUser();
    4343                void createDatabaseWithPrivilegedUser();
     44                void createDatabaseAndUserWithPrivilegedUser();
    4445               
    4546        private:
     
    4748                void printErrors(const QSignalSpy *spy);
    4849                void resetSettings();
     50                /**
     51                 * @brief Creates the database @p createDatabase and user @p createUser with @p password
     52                 *                and grants all privileges to @p createDatabase by user @p createUser.
     53                 *
     54                 * If @p manageUserOnly is set to true, the user is created and all privileges are granted to @p createDatabase.
     55                 * But the database itself is not created!
     56                 */
     57                void setupDatabase(QString createDatabase, QString createUser, QString userPassword, bool manageUserOnly = false);
     58                void cleanupDatabase(QString dropDatabase, QString dropUser);
    4959               
    5060                QString host, driver;
    5161                QString username, password;
    5262                QString usernameAdmin, passwordAdmin;
     63                QString databasePrefix;
     64                QString adminDatabaeConnectionName;
    5365};
    5466
Note: See TracChangeset for help on using the changeset viewer.