/****************************************************************************

**

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

** All rights reserved.

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

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include "../qsqldatabase/tst_databases.h"

#include <QtSql>

const QString test(qTableName("test", __FILE__)),

                   test2(qTableName("test2", __FILE__)),

                   test3(qTableName("test3", __FILE__));

//TESTED_CLASS=

//TESTED_FILES=

Q_DECLARE_METATYPE(QModelIndex)

class tst_QSqlTableModel : public QObject

{

    Q_OBJECT

public:

    tst_QSqlTableModel();

    virtual ~tst_QSqlTableModel();

    void dropTestTables();

    void createTestTables();

    void recreateTestTables();

    void repopulateTestTables();

    tst_Databases dbs;

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void select_data() { generic_data(); }

    void select();

    void submitAll_data() { generic_data(); }

    void submitAll();

    void setRecord_data()  { generic_data(); }

    void setRecord();

    void insertRow_data() { generic_data(); }

    void insertRow();

    void insertRecord_data() { generic_data(); }

    void insertRecord();

    void insertMultiRecords_data() { generic_data(); }

    void insertMultiRecords();

    void removeRow_data() { generic_data(); }

    void removeRow();

    void removeRows_data() { generic_data(); }

    void removeRows();

    void removeInsertedRow_data() { generic_data(); }

    void removeInsertedRow();

    void setFilter_data() { generic_data(); }

    void setFilter();

    void setInvalidFilter_data() { generic_data(); }

    void setInvalidFilter();

    void emptyTable_data() { generic_data(); }

    void emptyTable();

    void tablesAndSchemas_data() { generic_data("QPSQL"); }

    void tablesAndSchemas();

    void whitespaceInIdentifiers_data() { generic_data(); }

    void whitespaceInIdentifiers();

    void primaryKeyOrder_data() { generic_data("QSQLITE"); }

    void primaryKeyOrder();

    void sqlite_bigTable_data() { generic_data("QSQLITE"); }

    void sqlite_bigTable();

    // bug specific tests

    void insertRecordBeforeSelect_data() { generic_data(); }

    void insertRecordBeforeSelect();

    void submitAllOnInvalidTable_data() { generic_data(); }

    void submitAllOnInvalidTable();

    void insertRecordsInLoop_data() { generic_data(); }

    void insertRecordsInLoop();

    void sqlite_attachedDatabase_data() { generic_data("QSQLITE"); }

    void sqlite_attachedDatabase(); // For task 130799

    void tableModifyWithBlank_data() { generic_data(); }

    void tableModifyWithBlank(); // For mail task

    void removeColumnAndRow_data() { generic_data(); }

    void removeColumnAndRow(); // task 256032

    void insertBeforeDelete_data() { generic_data(); }

    void insertBeforeDelete();

private:

    void generic_data(const QString& engine=QString());

};

tst_QSqlTableModel::tst_QSqlTableModel()

{

    qRegisterMetaType<QModelIndex>("QModelIndex");

    dbs.open();

}

tst_QSqlTableModel::~tst_QSqlTableModel()

{

}

void tst_QSqlTableModel::dropTestTables()

{

    for (int i = 0; i < dbs.dbNames.count(); ++i) {

        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));

        QSqlQuery q(db);

        if(tst_Databases::isPostgreSQL(db))

            QVERIFY_SQL( q, exec("set client_min_messages='warning'"));

        QStringList tableNames;

        tableNames << test

                   << test2

                   << test3

                   << qTableName("test4", __FILE__)

                   << qTableName("emptytable", __FILE__)

                   << qTableName("bigtable", __FILE__)

                   << qTableName("foo", __FILE__);

        if (testWhiteSpaceNames(db.driverName()))

            tableNames << qTableName("qtestw hitespace", db.driver());

        tst_Databases::safeDropTables(db, tableNames);

        if (db.driverName().startsWith("QPSQL")) {

            q.exec("DROP SCHEMA " + qTableName("testschema", __FILE__) + " CASCADE");

        }

    }

}

void tst_QSqlTableModel::createTestTables()

{

    for (int i = 0; i < dbs.dbNames.count(); ++i) {

        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));

        QSqlQuery q(db);

        QVERIFY_SQL( q, exec("create table " + test + "(id int, name varchar(20), title int)"));

        QVERIFY_SQL( q, exec("create table " + test2 + "(id int, title varchar(20))"));

        QVERIFY_SQL( q, exec("create table " + test3 + "(id int, random varchar(20), randomtwo varchar(20))"));

        QVERIFY_SQL( q, exec("create table " + qTableName("emptytable", __FILE__) + "(id int)"));

        if (testWhiteSpaceNames(db.driverName())) {

            QString qry = "create table " + qTableName("qtestw hitespace", db.driver()) + " ("+ db.driver()->escapeIdentifier("a field", QSqlDriver::FieldName) + " int)";

            QVERIFY_SQL( q, exec(qry));

        }

    }

}

void tst_QSqlTableModel::repopulateTestTables()

{

    for (int i = 0; i < dbs.dbNames.count(); ++i) {

        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));

        QSqlQuery q(db);

        q.exec("delete from " + test);

        QVERIFY_SQL( q, exec("insert into " + test + " values(1, 'harry', 1)"));

        QVERIFY_SQL( q, exec("insert into " + test + " values(2, 'trond', 2)"));

        QVERIFY_SQL( q, exec("insert into " + test + " values(3, 'vohi', 3)"));

        q.exec("delete from " + test2);

        QVERIFY_SQL( q, exec("insert into " + test2 + " values(1, 'herr')"));

        QVERIFY_SQL( q, exec("insert into " + test2 + " values(2, 'mister')"));

        q.exec("delete from " + test3);

        QVERIFY_SQL( q, exec("insert into " + test3 + " values(1, 'foo', 'bar')"));

        QVERIFY_SQL( q, exec("insert into " + test3 + " values(2, 'baz', 'joe')"));

    }

}

void tst_QSqlTableModel::recreateTestTables()

{

    dropTestTables();

    createTestTables();

    repopulateTestTables();

}

void tst_QSqlTableModel::generic_data(const QString &engine)

{

    if ( dbs.fillTestTable(engine) == 0 ) {

        if(engine.isEmpty())

           QSKIP( "No database drivers are available in this Qt configuration", SkipAll );

        else

           QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );

    }

}

void tst_QSqlTableModel::initTestCase()

{

    recreateTestTables();

}

void tst_QSqlTableModel::cleanupTestCase()

{

    dropTestTables();

    dbs.close();

}

void tst_QSqlTableModel::init()

{

}

void tst_QSqlTableModel::cleanup()

{

    repopulateTestTables();

}

void tst_QSqlTableModel::select()

{

    QFETCH(QString, dbName);

    QSqlDatabase db = QSqlDatabase::database(dbName);

    CHECK_DATABASE(db);

    QSqlTableModel model(0, db);

    model.setTable(test);

    model.setSort(0, Qt::AscendingOrder);

    QVERIFY_SQL(model, select());

    QCOMPARE(model.rowCount(), 3);

    QCOMPARE(model.columnCount(), 3);

    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);

    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));

    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);

    QCOMPARE(model.data(model.index(0, 3)), QVariant());

    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);

    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));

    QCOMPARE(model.data(model.index(1, 2)).toInt(), 2);

    QCOMPARE(model.data(model.index(1, 3)), QVariant());

    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);

    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));

    QCOMPARE(model.data(model.index(2, 2)).toInt(), 3);

    QCOMPARE(model.data(model.index(2, 3)), QVariant());

    QCOMPARE(model.data(model.index(3, 0)), QVariant());

    QCOMPARE(model.data(model.index(3, 1)), QVariant());

    QCOMPARE(model.data(model.index(3, 2)), QVariant());

    QCOMPARE(model.data(model.index(3, 3)), QVariant());

}

void tst_QSqlTableModel::setRecord()

{

    QFETCH(QString, dbName);

    QSqlDatabase db = QSqlDatabase::database(dbName);

    CHECK_DATABASE(db);

    QList<QSqlTableModel::EditStrategy> policies = QList<QSqlTableModel::EditStrategy>() << QSqlTableModel::OnFieldChange << QSqlTableModel::OnRowChange << QSqlTableModel::OnManualSubmit;

    QString Xsuffix;

    foreach( QSqlTableModel::EditStrategy submitpolicy, policies) {

        QSqlTableModel model(0, db);

        model.setEditStrategy((QSqlTableModel::EditStrategy)submitpolicy);

        model.setTable(test3);

        model.setSort(0, Qt::AscendingOrder);

        QVERIFY_SQL(model, select());

        for (int i = 0; i < model.rowCount(); ++i) {

            QSignalSpy spy(&model, SIGNAL(dataChanged(QModelIndex,QModelIndex)));

            QSqlRecord rec = model.record(i);

            rec.setValue(1, rec.value(1).toString() + 'X');

            rec.setValue(2, rec.value(2).toString() + 'X');

            QVERIFY(model.setRecord(i, rec));

            if ((QSqlTableModel::EditStrategy)submitpolicy == QSqlTableModel::OnManualSubmit)

                QVERIFY(model.submitAll());

            else if ((QSqlTableModel::EditStrategy)submitpolicy == QSqlTableModel::OnRowChange && i == model.rowCount() -1)

                model.submit();

            else {

                // dataChanged() is not emitted when submitAll() is called

                QCOMPARE(spy.count(), 2);

                QCOMPARE(spy.at(0).count(), 2);

                QCOMPARE(qvariant_cast<QModelIndex>(spy.at(0).at(0)), model.index(i, 1));

                QCOMPARE(qvariant_cast<QModelIndex>(spy.at(0).at(1)), model.index(i, 1));

            }

        }

        Xsuffix.append('X');

        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("foo").append(Xsuffix));

        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("bar").append(Xsuffix));

        QCOMPARE(model.data(model.index(1, 1)).toString(), QString("baz").append(Xsuffix));

        QCOMPARE(model.data(model.index(1, 2)).toString(), QString("joe").append(Xsuffix));

    }

}

void tst_QSqlTableModel::insertRow()

{

    QFETCH(QString, dbName);

    QSqlDatabase db = QSqlDatabase::database(dbName);

    CHECK_DATABASE(db);

    QSqlTableModel model(0, db);

    model.setEditStrategy(QSqlTableModel::OnRowChange);

    model.setTable(test);

    model.setSort(0, Qt::AscendingOrder);

    QVERIFY_SQL(model, select());

    QVERIFY(model.insertRow(2));

    QSqlRecord rec = model.record(1);

    rec.setValue(0, 42);

    rec.setValue(1, QString("vohi"));

    QVERIFY(model.setRecord(2, rec));

    QCOMPARE(model.data(model.index(2, 0)).toInt(), 42);

    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));

    QCOMPARE(model.data(model.index(2, 2)).toInt(), 2);

    QVERIFY(model.submitAll());

}

void tst_QSqlTableModel::insertRecord()

{

    QFETCH(QString, dbName);

    QSqlDatabase db = QSqlDatabase::database(dbName);

    CHECK_DATABASE(db);

    QSqlTableModel model(0, db);

    model.setEditStrategy(QSqlTableModel::OnManualSubmit);

    model.setTable(test);

    model.setSort(0, Qt::AscendingOrder);

    QVERIFY_SQL(model, select());

    QSqlRecord rec = model.record();

    rec.setValue(0, 42);

    rec.setValue(1, QString("vohi"));

    rec.setValue(2, 1);

    QVERIFY(model.insertRecord(1, rec));

    QCOMPARE(model.rowCount(), 4);

    QCOMPARE(model.data(model.index(1, 0)).toInt(), 42);

    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("vohi"));

    QCOMPARE(model.data(model.index(1, 2)).toInt(), 1);

    model.revertAll();

    model.setEditStrategy(QSqlTableModel::OnRowChange);

    QVERIFY(model.insertRecord(-1, rec));

    QCOMPARE(model.data(model.index(3, 0)).toInt(), 42);

    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("vohi"));

    QCOMPARE(model.data(model.index(3, 2)).toInt(), 1);

}

void tst_QSqlTableModel::insertMultiRecords()

{

    QFETCH(QString, dbName);

    QSqlDatabase db = QSqlDatabase::database(dbName);

    CHECK_DATABASE(db);

    QSqlTableModel model(0, db);

    model.setEditStrategy(QSqlTableModel::OnManualSubmit);

    model.setTable(test);

    model.setSort(0, Qt::AscendingOrder);

    QVERIFY_SQL(model, select());

    QCOMPARE(model.rowCount(), 3);

    QVERIFY(model.insertRow(2));

    QCOMPARE(model.data(model.index(2, 0)), QVariant());

    QCOMPARE(model.data(model.index(2, 1)), QVariant());

    QCOMPARE(model.data(model.index(2, 2)), QVariant());

    QVERIFY(model.insertRow(3));

    QVERIFY(model.insertRow(0));

    QCOMPARE(model.data(model.index(5, 0)).toInt(), 3);

    QCOMPARE(model.data(model.index(5, 1)).toString(), QString("vohi"));

    QCOMPARE(model.data(model.index(5, 2)).toInt(), 3);

    QVERIFY(model.setData(model.index(0, 0), QVariant(42)));

    QVERIFY(model.setData(model.index(3, 0), QVariant(43)));

    QVERIFY(model.setData(model.index(4, 0), QVariant(44)));

    QVERIFY(model.setData(model.index(4, 1), QVariant(QLatin1String("gunnar"))));

    QVERIFY(model.setData(model.index(4, 2), QVariant(1)));

    QVERIFY(model.submitAll());

    model.clear();

    model.setTable(test);

    model.setSort(0, Qt::AscendingOrder);

    QVERIFY_SQL(model, select());

    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);

    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);

    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);

    QCOMPARE(model.data(model.index(3, 0)).toInt(), 42);

    QCOMPARE(model.data(model.index(4, 0)).toInt(), 43);

    QCOMPARE(model.data(model.index(5, 0)).toInt(), 44);

    QCOMPARE(model.data(model.index(5, 1)).toString(), QString("gunnar"));

    QCOMPARE(model.data(model.index(5, 2)).toInt(), 1);

}

void tst_QSqlTableModel::submitAll()

{

    QFETCH(QString, dbName);

    QSqlDatabase db = QSqlDatabase::database(dbName);

    CHECK_DATABASE(db);

    QSqlTableModel model(0, db);

    model.setTable(test);

    model.setSort(0, Qt::AscendingOrder);

    model.setEditStrategy(QSqlTableModel::OnManualSubmit);

    QVERIFY_SQL(model, select());

    QVERIFY(model.setData(model.index(0, 1), "harry2", Qt::EditRole));

    QVERIFY(model.setData(model.index(1, 1), "trond2", Qt::EditRole));

    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));

    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond2"));

    QVERIFY_SQL(model, submitAll());

    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));

    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond2"));

    QVERIFY(model.setData(model.index(0, 1), "harry", Qt::EditRole));

    QVERIFY(model.setData(model.index(1, 1), "trond", Qt::EditRole));

    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));

    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));

    QVERIFY_SQL(model, submitAll());

    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));

    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));

}

void tst_QSqlTableModel::removeRow()

{

    QFETCH(QString, dbName);

    QSqlDatabase db = QSqlDatabase::database(dbName);

    CHECK_DATABASE(db);

    QSqlTableModel model(0, db);

    model.setTable(test);

    model.setSort(0, Qt::AscendingOrder);

    model.setEditStrategy(QSqlTableModel::OnManualSubmit);

    QVERIFY_SQL(model, select());

    QCOMPARE(model.rowCount(), 3);

    // headerDataChanged must be emitted by the model when the edit strategy is OnManualSubmit,

    // when OnFieldChange or OnRowChange it's not needed because the model will re-select.

    qRegisterMetaType<Qt::Orientation>("Qt::Orientation");

    QSignalSpy headerDataChangedSpy(&model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)));

    QVERIFY(model.removeRow(1));

    QCOMPARE(headerDataChangedSpy.count(), 1);

    QCOMPARE(*static_cast<const Qt::Orientation *>(headerDataChangedSpy.at(0).value(0).constData()), Qt::Vertical);

    QCOMPARE(headerDataChangedSpy.at(0).at(1).toInt(), 1);

    QCOMPARE(headerDataChangedSpy.at(0).at(2).toInt(), 1);

    QVERIFY(model.submitAll());

    QCOMPARE(model.rowCount(), 2);

    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);

    QCOMPARE(model.data(model.index(1, 0)).toInt(), 3);

    model.clear();

    recreateTestTables();

    model.setTable(test);

    model.setEditStrategy(QSqlTableModel::OnRowChange);

    QVERIFY_SQL(model, select());

    QCOMPARE(model.rowCount(), 3);

    headerDataChangedSpy.clear();

    QVERIFY(model.removeRow(1));

    QCOMPARE(headerDataChangedSpy.count(), 0);

    QCOMPARE(model.rowCount(), 2);

    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));