JUnit, DbUnit, tests unitaires en Java [Résolu]

Réponse 1 / 8

Miko
8 oct. 2007 à 10:55

Bonjour,

Merci pour tes précisions. Apparemment, je devrais utiliser JUnit, et je crois en effet qu'il faut cet ensemble de classes. J'ai aussi découvert que Ant, présent sous Eclipse, me permettait de faire ces tests grâce à l'extension DbUnit. Je le ferais donc en XML, ce qui sera plus rapide que de faire en Java, car mon fichier XML me recréera mon environnement de base de données en réinitialisant la base afin de faire mes tests dessus. En plus, il sera plus rapide de faire les tests car il faudra pas à chaque fois de recompiler le code Java...

Je me renseigne à propos de DbUnit et de XML, et je repost.

Mais si jamais quelqu'un est calé la-dedans, des conseils avisés ne seraient pas de refus !

Merci

Réponse 2 / 8

Miko
16 oct. 2007 à 10:19

Bonjour,

C'est encore moi. Alors... après quelques temps, j'ai réussi à recréer un environnement de test à partir d'une base de données existante, mais désormais, je dois créer mes tests.
J'utilise des scripts JUnit et DbUnit, mais je n'arrive à tester pour le moment que deux choses par rapport aux base de données : la connexion et la déconnexion. Maintenant, il faut que je sache tester les requêtes de base : SELECT, INSERT, UPDATE, DELETE.

Je post ici mon code de test et ainsi que la classe testée :

package dumpMySQL;

import java.sql.*;

/**
 * TestClass on which we will test the JUnit framework
 * 
 * @author Michaël
 */
public class DbCRUD
{
    Connection m_connection;

    /**
     * Connection to the tested database
     */
    public void connect()
    {
        try
        {
            Class.forName( "com.mysql.jdbc.Driver" );

            String sURL = "jdbc:mysql://localhost/testjunit";
            m_connection = DriverManager.getConnection( sURL, "root", "root" );
        }catch( ClassNotFoundException e )
        {
            System.out.println( "Le driver de connexion n'a pas pû être trouvé : " + e );
        }catch( SQLException sqlE )
        {
            System.out.println( "La connexion n'a pas fonctionné : " + sqlE );
        }
    }

    /**
     * Data insertion function
     */
    public void insertion()
    {
        try
        {
            Statement stmtInsert = m_connection.createStatement();

            StringBuffer sbInsert = new StringBuffer();
            sbInsert.append( "INSERT INTO " );
            sbInsert.append( "" );
            sbInsert.append( "" );
            sbInsert.append( "" );
            sbInsert.append( "" );
            sbInsert.append( "" );

            String sInsert = sbInsert.toString();
            stmtInsert.execute( sInsert );
            stmtInsert.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête d'insertion n'a pas fonctionné : " + sqlE );
        }
    }

    /**
     * Data display function
     */
    public void select()
    {
        try
        {
            Statement stmtSelect = m_connection.createStatement();

            StringBuffer sbSelect = new StringBuffer();
            sbSelect.append( "SELECT " );
            sbSelect.append( "* " );
            sbSelect.append( "FROM " );
            sbSelect.append( "user" );
            sbSelect.append( ";" );

            String sSelect = sbSelect.toString();
            stmtSelect.executeQuery( sSelect );
            ResultSet result = stmtSelect.executeQuery( sSelect );
            while( result.next() )
            {
                StringBuffer sbResult = new StringBuffer();
                String sId = ( "user.id" );
                String sPseudo = ( "user.pseudo" );
                String sAge = ( "user.age" );

                sbResult.append( sId );
                sbResult.append( sPseudo );
                sbResult.append( sAge );

                System.out.println( sbResult.toString() );
            }

            stmtSelect.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête d'affichage n'a pas fonctionné : " + sqlE );
        }
    }

    /**
     * Data updating function
     */
    public void update()
    {
        try
        {
            Statement stmtUpdate = m_connection.createStatement();

            StringBuffer sbUpdate = new StringBuffer();
            sbUpdate.append( "UPDATE " );
            sbUpdate.append( "" );
            sbUpdate.append( "" );
            sbUpdate.append( "" );
            sbUpdate.append( "" );

            String sUpdate = sbUpdate.toString();
            stmtUpdate.executeUpdate( sUpdate );
            stmtUpdate.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête de mise à jour n'a pas fonctionné : " + sqlE );
        }
    }

    /**
     * Data deleting function
     */
    public void delete()
    {
        try
        {
            Statement stmtDelete = m_connection.createStatement();

            StringBuffer sbDelete = new StringBuffer();
            sbDelete.append( "DELETE " );
            sbDelete.append( "" );
            sbDelete.append( "" );
            sbDelete.append( "" );
            sbDelete.append( "" );

            String sDelete = sbDelete.toString();
            stmtDelete.executeUpdate( sDelete );
            stmtDelete.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête de suppression n'a pas fonctionné : " + sqlE );
        }
    }

    public void disconnect()
    {
        try
        {
            m_connection.close();
        }catch( SQLException sqlE )
        {
            System.out.println( "La connexion n'a pas pû se fermer : " + sqlE );
        }
    }

    protected void finalize() throws Throwable
    {
        super.finalize();
        if( isConnected() )
        {
            disconnect();
        }
    }

    public boolean isConnected()
    {
        boolean bReturn = true;
        try
        {
            bReturn = m_connection != null && !m_connection.isClosed();
        }catch( SQLException sqlE )
        {
            System.out.println( "Non connecté : " + sqlE );
        }
        return bReturn;
    }

    public static void main( String[] args )
    {
    // DbCRUD crud = new DbCRUD();
    }
}

Voila pour ma classe à tester...

Maintenant, ma classe de test :

package dumpMySQL;

import junit.framework.TestCase;

import org.dbunit.Assertion;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.ITable;
import org.dbunit.database.DatabaseConnection;
import java.sql.*;

public class DbCRUDTest extends TestCase
{
    private DbCRUD dbcrud;

    protected void setUp() throws Exception
    {
        dbcrud = new DbCRUD();
    }

    protected void tearDown() throws Exception
    {
        dbcrud = null;
    }

    public void testConnection()
    {
        dbcrud.connect();
        assertNotNull( "La connexion est nulle", dbcrud.m_connection );
        assertTrue( "La connection n'est pas établie", dbcrud.isConnected() );
    }

    public void testDisconnect()
    {
        dbcrud.connect();
        dbcrud.disconnect();
        assertFalse( "", dbcrud.isConnected() );
        
    }

Ici, c'est ma méthode de test de la requête SELECT... mais elle est fausse

    public void testSelect()
    {
    	dbcrud.connect();
    	dbcrud.select();
    	DatabaseConnection dbConnection = new DatabaseConnection(dbcrud.m_connection);
    	dbcrud.disconnect();
    	try
    	{
            //IDataSet databaseDataSet = getConnection().createDataSet();
            //ITable actualTable = databaseDataSet.getTable("TABLE_NAME");
    		ITable exceptedData = dbConnection.createQueryTable("Result", "SELECT * FROM user;");
    		ITable knownData = ?????????
    	}
    	catch(SQLException sqlE){
    		
    	}
    	catch(DataSetException dtsE){
    		
    	}
    	
    }
}

Voila voila !

Si quelqu'un peut m'expliquer comment faire pour tester mes requêtes, il est le bienvenu !!!

Merci d'avance,

Miko

Réponse 3 / 8

caltoune
6 oct. 2007 à 04:42

Bonjour,

il existe différents types de tests:
boite blanche -> Intérieur des méthodes : essayer au fur et a mesure différentes entrées et valider que les sorties sont bonnes.
boite noire -> Utiliser les interfaces i.e. les méthodes des classes pour voir s'il elles font ce qui est attendu.
intégration -> Tester plus globalement l'interaction entre les classes

Je sais que pour tester une classe "UneClasse.java" il est recommandé d'utiliser systématiquement une classe séparée ''TestUneClasse.java". Ca permet de couvrir les tests unitaires et s'assurer que les méthodes attendues
existent bien dans la classe à tester.

Pour JUnit je suis pas mal certain qu'il faut cet ensemble de classes de test pour chaque classe existente ou en voie de le devenir.

Si quelqu'un s'y connait en test, ca m'intéresse aussi!

Réponse 4 / 8

Miko
10 oct. 2007 à 10:18

Re moi !

Petite précision : ma tentative de création d'un environnement de test en XML (donc en utilisant l'extension DbUnit) n'a pas marché.
Je rappelle que mon boulot sera d'effectuer des tests sur des bases de données avec JUnit, et que pour ça, il me faut recréer un environnement de base de données, d'une base existante et connue à un instant t. Pour ce faire, il m'a donc été nécessaire de faire les étapes suivantes :

- Créer un fichier SQL grâce à un mysqldump : en effet, pour récupérer la base de données connue à un instant t dans un état connu, j'ai fait un mysqldump, qui m'a créé un fichier .sql qui possède tout la structure de la base de données, ainsi que les données à l'intérieur. Sans spécifier de chemin pour la création de ce fichier, il se place automatiquement dans le projet.

- Créer un nouveau schéma (ou nouvelle base de données) qui va accueillir les données de mon fichier .sql, si cette base n'existe pas déjà (en utilisant la commande SQL "CREATE SCHEMA IF NOT EXISTS ma_base;").

- Remplir la base de données vierge ou non (le Dump efface les données pré-existantes et les remplacent par celles à l'intérieur du fichier .sql grâce à des instructions SQL DROP) avec le fichier .sql créé grâce au Dump.

- Supprimer le fichier "dumpé" qui faisait office ici de fichier temporaire.

Si jamais quelqu'un a besoin d'un peu d'aide, qu'il se manifeste, je pourrais poster mon code, sans soucis !

J'ai donc bien créé mon environnement de test. Maintenant, j'aimerais bien savoir quelle sera la marche à suivre pour effectuer mes tests avec JUnit.

Merci d'avance !

PS: j'utilise MySQL comme logiciel de base de données.

Réponse 5 / 8

Miko
29 oct. 2007 à 12:01

Hello tout le monde !

Alors comme vous le savez, je suis le seul à poster ici mais en meme temps, j'ai pas mal avancé... donc si jamais il y a des personnes qui ont besoin de précisions sur les tests unitaires avec JUnit et pas DbUnit (j'y arrive pas trop :s), j'espère que je les auraient aidé, pas comme moi qui ai galéré !

Bref, fini la discussion, voila ici mon code, pas très commenté, désolé, mais si vous voulez des précisions, postez des réponses. J'ai également mis des données qui correspondent à une base de données toute simple possédant une table et 3 champs : Id, pseudo et age.

Ici la classe à tester :

package dumpMySQL;

import java.sql.*;

/**
 * TestClass on which we will test the JUnit framework
 * 
 * @author Mickael
 * @version 0.8.1
 */
public class DbCRUD
{
    Connection m_connection;

    /**
     * Connection to the tested database
     */
    public void connect()
    {
        try
        {
            Class.forName( "com.mysql.jdbc.Driver" );

            String sURL = "jdbc:mysql://localhost/testjunit";
            m_connection = DriverManager.getConnection( sURL, "root", "root" );
        }catch( ClassNotFoundException e )
        {
            System.out.println( "Le driver de connexion n'a pas pû être trouvé : " + e );
        }catch( SQLException sqlE )
        {
            System.out.println( "La connexion n'a pas fonctionné : " + sqlE );
        }
    }

    /**
     * Data insertion function
     */
    public void insert( String sTable, String sValeurs )
    {
        try
        {
            Statement stmtInsert = m_connection.createStatement();

            StringBuffer sbInsert = new StringBuffer();
            sbInsert.append( "INSERT INTO " );
            sbInsert.append( sTable );
            sbInsert.append( " VALUES " );
            sbInsert.append( sValeurs );
            sbInsert.append( ";" );

            String sInsert = sbInsert.toString();
            stmtInsert.execute( sInsert );
            stmtInsert.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête d'insertion n'a pas fonctionné : " + sqlE );
        }
    }

    /**
     * Data display function
     */
    public String select( String sChamps, String sTable, String sCondition )
    {
        StringBuffer sbResult = new StringBuffer();
        try
        {
            Statement stmtSelect = m_connection.createStatement();

            StringBuffer sbSelect = new StringBuffer();
            sbSelect.append( "SELECT " );
            sbSelect.append( sChamps );
            sbSelect.append( " FROM " );
            sbSelect.append( sTable );

            if( sCondition != null && !sCondition.equals( "" ) )
            {
                sbSelect.append( " WHERE " );
                sbSelect.append( sCondition );
            }
            sbSelect.append( ";" );

            String sSelect = sbSelect.toString();
            stmtSelect.executeQuery( sSelect );
            ResultSet result = stmtSelect.executeQuery( sSelect );
            ResultSetMetaData resultMD = result.getMetaData();
            int iColumnCount = resultMD.getColumnCount();
            int i = 1;
            while( result.next() )
            {
                for( i = 1; i <= iColumnCount; i++ )
                {
                    String sColumn = result.getString( i );

                    sbResult.append( sColumn );
                    sbResult.append( " " );
                }
                sbResult.setLength( sbResult.length() - 1 );
                sbResult.append( "\n" );
            }
            stmtSelect.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête d'affichage n'a pas fonctionné : " + sqlE );
        }
        return sbResult.toString();
    }

    /**
     * Data updating function
     */
    public void update( String sTable, String sUpdateData, String sCondition, String sOrder, String sLimit )
    {
        try
        {
            Statement stmtUpdate = m_connection.createStatement();

            StringBuffer sbUpdate = new StringBuffer();
            sbUpdate.append( "UPDATE " );
            sbUpdate.append( sTable );
            sbUpdate.append( " SET " );
            sbUpdate.append( sUpdateData );
            if( sCondition != null && !sCondition.equals( "" ) )
            {
                sbUpdate.append( " WHERE " );
                sbUpdate.append( sCondition );
            }
            if( sOrder != null && !sOrder.equals( "" ) )
            {
                sbUpdate.append( " ORDER BY " );
                sbUpdate.append( sOrder );
            }
            if( sLimit != null && !sLimit.equals( "" ) )
            {
                sbUpdate.append( " LIMIT " );
                sbUpdate.append( sLimit );
            }
            sbUpdate.append( ";" );
            
            String sUpdate = sbUpdate.toString();
            stmtUpdate.executeUpdate( sUpdate );
            stmtUpdate.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête de mise à jour n'a pas fonctionné : " + sqlE );
        }
    }

    /**
     * Data deleting function
     */
    public void delete( String sTable, String sCondition )
    {
        try
        {
            Statement stmtDelete = m_connection.createStatement();

            StringBuffer sbDelete = new StringBuffer();
            sbDelete.append( "DELETE " );
            sbDelete.append( "FROM " );
            sbDelete.append( sTable );
            sbDelete.append( " WHERE " );
            sbDelete.append( sCondition );
            sbDelete.append( ";" );

            String sDelete = sbDelete.toString();
            stmtDelete.executeUpdate( sDelete );
            stmtDelete.close();

        }catch( SQLException sqlE )
        {
            System.out.println( "La requête de suppression n'a pas fonctionné : " + sqlE );
        }
    }

    public void disconnect()
    {
        try
        {
            m_connection.close();
        }catch( SQLException sqlE )
        {
            System.out.println( "La connexion n'a pas pû se fermer : " + sqlE );
        }
    }

    protected void finalize() throws Throwable
    {
        super.finalize();
        if( isConnected() )
        {
            disconnect();
        }
    }

    public boolean isConnected()
    {
        boolean bReturn = true;
        try
        {
            bReturn = m_connection != null && !m_connection.isClosed();
        }catch( SQLException sqlE )
        {
            System.out.println( "Non connecté : " + sqlE );
        }
        return bReturn;
    }

    public static void main( String[] args )
    {
        DbCRUD crud = new DbCRUD();
        crud.connect();
        crud.select( "*", "testjunit.user", "" );
    }
}

Ici la classe de Dump qui me permet de récupérer une base de données qu'on utilisera pour faire les tests (je précise que la classe à tester se trouve dans un projet différent de la classe de Dump et de la classe de test) :

package dumpMySQL;
import java.io.File;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * Create a new environment of test with a new Database from a existing schema
 * 
 * @author Mickael Steinberg
 */

public class MysqlDump
{
    boolean m_bFailure = false;

    /**
     *  Creation of a SQL file using a mysqldump
     */
    public void DatabaseToDump()
    {
        try
        {
            String sCommand = "mysqldump -u root -proot -h localhost -r dump.sql test";
            Process pChild = Runtime.getRuntime().exec( sCommand );
            System.out.println( "Le Dump est lancé......." );
            pChild.waitFor();
            System.out.println( "Le fichier SQL a été créé avec succès !" );
        }catch( java.io.IOException jIOE )
        {
            System.out.println( "Erreur d'écriture sur le fichier : " + jIOE.getMessage() );
            jIOE.printStackTrace();
            m_bFailure = true;
        }catch( InterruptedException InE )
        {
            System.out.println( "Erreur lors de l'éxécution : " + InE.getMessage() );
            InE.printStackTrace();
            m_bFailure = true;
        }
    }

    /**
     *  If a database doesn't exist, creation of a new schema
     */
    public void SchemaCreation()
    {
        try
        {
            Class.forName( "com.mysql.jdbc.Driver" );
            String sURL = "jdbc:mysql://localhost/";

            try
            {
                Connection con = DriverManager.getConnection( sURL, "root", "root" );
                Statement stmt = con.createStatement();
                String sDROP = "DROP SCHEMA IF EXISTS TestJunit";
                stmt.execute( sDROP );
                String sSQL = "CREATE SCHEMA IF NOT EXISTS TestJUnit";
                stmt.execute( sSQL );
                System.out.println( "La base a bien été réinitialisée !" );
                stmt.close();
                con.close();
            }catch( SQLException SQLe )
            {
                System.out.println( "La création du schéma 'basetest' n'a pas fonctionné : " + SQLe.getMessage() );
                m_bFailure = true;
            }
        }catch( Exception e )
        {
            System.out.println( "Erreur lors de la connexion ou du chargement du driver" + e.getMessage() );
            m_bFailure = true;
        }

    }

    /**
     *  Using the SQL file, we fill the schema created above with the dump file data
     */
    public void DumpToDatabase()
    {
        try
        {
            String sCommand = "mysql -u root -proot -h localhost -e \"source dump.sql\" TestJUnit";
            Process pChild = Runtime.getRuntime().exec( sCommand );
            System.out.println( "L'écriture du Dump dans la base est en cours......." );
            pChild.waitFor();
            System.out.println( "La base de données a été créée avec succès !!!" );
            System.out.println( "Vous pouvez désormais utiliser cette nouvelle base comme test !!!" );
            System.out.println( "PS: Mickael, t'es vraiment le meilleur !" );
        }catch( java.io.IOException jIOE )
        {
            System.out.println( "L'écriture du fichier Dump dans la base n'a pas fonctionné : " + jIOE.getMessage() );
            jIOE.printStackTrace();
            m_bFailure = true;
        }catch( InterruptedException InE )
        {
            System.out.println( "Erreur lors de l'éxécution : " + InE.getMessage() );
            InE.printStackTrace();
            m_bFailure = true;
        }
    }

    /**
     *  When new environment created, delete the dump file
     */
    public void DumpDelete()
    {
        try
        {
            File dump = new File( "dump.sql" );
            dump.delete();
            System.out.println("Le fichier Dump a bien été supprimé !");
        }catch( Exception e )
        {
            System.out.println( "Le fichier n'a pas pû être supprimé : " + e.getMessage() );
            m_bFailure = true;
        }
    }

    public static void main( String args[] )
    {
        MysqlDump mySqlDump = new MysqlDump();
        mySqlDump.DatabaseToDump();
        if( !mySqlDump.m_bFailure )
        {
            mySqlDump.SchemaCreation();
            if( !mySqlDump.m_bFailure )
            {
                mySqlDump.DumpToDatabase();
                if( !mySqlDump.m_bFailure )
                {
                    mySqlDump.DumpDelete();
                }
            }
        }
    }
}

Et en enfin, la classe de test :

package dumpMySQL;

import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 * @author Mickael
 * @see dumpMySQL.DbCRUD
 * @version 0.5
 */
public class DbCRUDTest
{
    private DbCRUD dbcrud;

    @BeforeClass
    public static void initDB()
    {
        MysqlDump mySqlDump = new MysqlDump();
        mySqlDump.DatabaseToDump();
        mySqlDump.SchemaCreation();
        mySqlDump.DumpToDatabase();
        mySqlDump.DumpDelete();
    }
    
    @Before
    public void setUp() throws Exception
    {
        dbcrud = new DbCRUD();
    }

    @After
    public void tearDown() throws Exception
    {
        if( dbcrud.isConnected() )
            dbcrud.disconnect();
    }

    @Test
    public void testConnection()
    {
        dbcrud.connect();
        assertNotNull( "La connexion est nulle", dbcrud.m_connection );
        assertTrue( "La connection n'est pas établie", dbcrud.isConnected() );
    }

    @Test
    public void testDisconnect()
    {
        dbcrud.connect();
        dbcrud.disconnect();
        assertFalse( "La connexion n'a pas été fermé", dbcrud.isConnected() );
    }

    @Test
    public void testCRUD()
    {
        dbcrud.connect();

        // Test function "insert"
        dbcrud.insert( "user(pseudo, age)", "(\"jeremy\", 16)" );
        String sSelect = dbcrud.select( "user.pseudo, user.age", "user", "pseudo=\"jeremy\" AND age=16" );
        String sResult = "jeremy 16\n";
        assertEquals( "La requête d'insertion n'a pas fonctionné.", sSelect, sResult );

        // Test function "update"
        dbcrud.update( "testjunit.user", "user.pseudo=\"Guillaume\", user.age=24", "user.pseudo=\"jeremy\" AND user.age=16", "", "" );
        sSelect = dbcrud.select( "user.pseudo, user.age", "user", "pseudo=\"Guillaume\" AND age=24" );
        sResult = "Guillaume 24\n";
        assertEquals( "La requête de mise à jour n'a pas fonctionné.", sSelect, sResult );

        // Test function "delete"
        dbcrud.delete( "testjunit.user", "pseudo=\"Guillaume\" AND age=24" );
        sSelect = dbcrud.select( "user.pseudo, user.age", "user", "pseudo=\"Guillaume\" AND age=24" );
        assertTrue( "La requête de suppression n'a pas fonctionné.", sSelect.equals( "" ) );
    }
}

Voila ! C'est à peu près tout. Maintenant il est largement possible d'améliorer ce code, qui est somme toute assez basique. Par exemple, vous pouvez, au lieu de passer les données de test en dur dans la classe de test, les passer en properties... Enfin, ça c'est une possibilité comme une autre...

J'espere que ce code vous aura aidé, et si jamais vous ne comprenez pas... posez des questions n'hésitez pas !

PS: il faut insérer dans le buildpath des jar de junit (junit 4.4) et aussi de mysql (mysqlconnector).

Réponse 6 / 8

insaf
11 déc. 2007 à 21:53

slt, je vois que toi au moin tu t'en ai bien sorti, moi par contre je ne travaille pas mais j'ai un exposé sur cppunit, c comme junit mais ça marche sur visual studio, et du moment que je n'ai jamais travaillé sur vstudio ni avc cppunit je galère, j'espere que tu pourra m'aider, un exple d'application sur visual studio + un programme de test comprehensible avec toutes les étapes à suivre ça serait pas mal, sachant que je suis assez illétrée, je programme depuis tjrs avec dev c++, un epu de delphi avc oracle comme SGBD mais la je dois comme meme me developper... avc visual studio, merci

Réponse 7 / 8

Mycki Messages postés 113 Date d'inscription jeudi 8 novembre 2007 Statut Membre Dernière intervention 17 décembre 2007 46
12 déc. 2007 à 12:09

Salut insaf ! C'est Miko (mais je me suis inscrit sous le nom de Mycki maintenant)

Je suis désolé, je n'ai jamais travaillé sous VS qu'avec VB.NET et en plus, à cette époque, il n'était pas question de créer des tests unitaires.
De plus, je n'ai jamais fait (du moins pour le moment, mais ca va venir) de C++.

Ce que j'ai fait, c'est du Java avec JUnit, mais ça tu l'as vu. Si jamais tu as des questions sur la méthode, et sur quels tests tu dois effectuer sur une base de données, je peux t'aider, mais ça ne restera que théorique. Je connais maintenant à peu près tout sur ces méthodes de développement.
Désolé de ne pouvoir t'aider plus.

Peut etre que cette piste t'aidera à démarrer : Essaye de regarder les différentes fonctions qui sont contenues dans le framework de cppunit, ensuite, regarde les fonctions que tu veux tester, et regarde ce qu'elles font. Tu développeras ton test en fonction d'un résultat que doit t'apporter une méthode.

Pour un exemple concret de ce que je suis en train de dire, j'ai développé un test qui me permet de vérifier qu'un id dans une base de données est bien auto incrémenté :
- Je fais une requete de selection sur la base en ne prenant que les id
- Je crée deux tableaux
- Je rempli mon premier tableau avec ce qu'il y a dans la requete de sélection des id
- J'insère ici des données sans donner d'id pour qu'il s'ajoute de lui même
- Je refais ma requete de sélection avec les id
- Je rempli mon deuxième tableau avec les id présents
- TEST : taille des deux tableaux (vérifier que le deuxieme possède un élément de plus que le premier)
- TEST : numéro de l'id inséré par rapport à un id que j'ai passé au test.

Voila... c'est à peu près tout ce que je peux faire pour toi.

N'hésite pas à me recontacter ;)

Réponse 8 / 8

lonapat Messages postés 15 Date d'inscription mardi 3 février 2009 Statut Membre Dernière intervention 2 janvier 2012
6 févr. 2009 à 12:16

Bonjour, je serai ravi que vous me veniez en aide.En fait je voudrais utiliser testlink et selenium pour automatiser mes test,mais seulement je ne connait pas comment m'y prendre pour ecrire des cas de tests et rediriger directyement les bugs sur su bugzilla.
SVP aidez moi

JUnit, DbUnit, tests unitaires en Java

8 réponses

Discussions similaires

Newsletters