Tutoriel sur la présentation de Benerator : un outil de génération de jeux de données

Antonio Gomes-Rodrigues

Afin qu'une campagne de tests de charge soit la plus utile possible, il est souvent nécessaire d'avoir un jeu de données volumineux et réaliste. Pour cela plusieurs solutions existent :

- importation des données de la base de données de production ;

- création du jeu de données à l'aide d'outils maison ;

- utilisation d'ETL ;

- utilisation de l'outil de test de charge et/ou de test fonctionnel afin d'exécuter des scripts qui vont remplir la base ;

- utilisation d'outil de création de données.

Nous allons nous focaliser sur la dernière solution avec l'utilisation de l'outil Benerator qui couvre largement ce besoin.

Un espace de dialogue vous est proposé sur le forum : Commentez pour vous permettre de réagir sur ce tutoriel.

- Titre : Tutoriel sur la présentation de Benerator : un outil de génération de jeux de données

- Auteur : Antonio Gomes-Rodrigues

- Parution : 12 février 2012

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2015 Antonio Gomes-Rodrigues. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Un peu de théorie

- II. Passons à la pratique

- II-A. Présentation du cas de test

- II-B. Paramétrage de la base de données cible et de la volumétrie du jeu de données

- II-C. Création du fichier de description de Benerator

- III. Conclusion

- IV. Remerciements

I - Un peu de théorie

Pour la partie théorique et quelques exemples, je vous laisse aller sur le site officiel et sur mon précédent article sur developpez.com.

II - Passons à la pratique

II-A - Présentation du cas de test

Dans cet article nous allons nous pencher sur la création de plusieurs jeux de données pour l'application démo PlantsByWebSphere livrée avec IBM WebSphere 8. Nous utiliserons une base de données MySQL en remplacement de Derby.

PlantsByWebSphere est une démonstration de boutique en ligne comme vous pouvez le voir sur cette capture d'écran.

On remarque que :

- les produits sont divisés en quatre catégories (Flowers, Fruits & Vegetables, Trees et Accessories) ;

- l'application gère des comptes clients ;

- l'application gère un panier d'achats.

Regardons d'un peu plus près le schéma de la base de données.

Et son code SQL.

1. CREATE TABLE CUSTOMER(

2. CUSTOMERID VARCHAR(250) NOT NULL,

3. PASSWORD VARCHAR(250),

4. FIRSTNAME VARCHAR(250),

5. LASTNAME VARCHAR(250),

6. ADDR1 VARCHAR(250),

7. ADDR2 VARCHAR(250),

8. ADDRCITY VARCHAR(250),

9. ADDRSTATE VARCHAR(250),

10. ADDRZIP VARCHAR(250),

11. PHONE VARCHAR(250)

12. );

14. ALTER TABLE CUSTOMER

15. ADD CONSTRAINT PK_CUSTOMER PRIMARY KEY (CUSTOMERID);

17. CREATE TABLE INVENTORY(

18. INVENTORYID VARCHAR(250) NOT NULL,

19. NAME VARCHAR(250),

20. HEADING VARCHAR(250),

21. DESCRIPTION VARCHAR(250),

22. PKGINFO VARCHAR(250),

23. IMAGE VARCHAR(250),

24. IMGBYTES LONG BIT VARYING,

25. PRICE REAL,

26. COST REAL,

27. CATEGORY INTEGER,

28. QUANTITY INTEGER,

29. NOTES VARCHAR(250),

30. ISPUBLIC INTEGER,

31. MINTHRESHOLD INTEGER NOT NULL,

32. MAXTHRESHOLD INTEGER NOT NULL

33. );

35. ALTER TABLE INVENTORY

36. ADD CONSTRAINT PK_INVENTORY PRIMARY KEY (INVENTORYID);

38. CREATE TABLE ORDER1(

39. ORDERID VARCHAR(250) NOT NULL,

40. SELLDATE VARCHAR(250),

41. BILLNAME VARCHAR(250),

42. BILLADDR1 VARCHAR(250),

43. BILLADDR2 VARCHAR(250),

44. BILLCITY VARCHAR(250),

45. BILLSTATE VARCHAR(250),

46. BILLZIP VARCHAR(250),

47. BILLPHONE VARCHAR(250),

48. SHIPNAME VARCHAR(250),

49. SHIPADDR1 VARCHAR(250),

50. SHIPADDR2 VARCHAR(250),

51. SHIPCITY VARCHAR(250),

52. SHIPSTATE VARCHAR(250),

53. SHIPZIP VARCHAR(250),

54. SHIPPHONE VARCHAR(250),

55. CREDITCARD VARCHAR(250),

56. CCNUM VARCHAR(250),

57. CCEXPIREMONTH VARCHAR(250),

58. CCEXPIREYEAR VARCHAR(250),

59. CARDHOLDER VARCHAR(250),

60. SHIPPINGMETHOD INTEGER NOT NULL,

61. PROFIT REAL NOT NULL,

62. CUSTOMERID VARCHAR(250)

63. );

65. ALTER TABLE ORDER1

66. ADD CONSTRAINT PK_ORDER1 PRIMARY KEY (ORDERID);

68. CREATE TABLE ORDERITEM(

69. INVENTORYID VARCHAR(250) NOT NULL,

70. NAME VARCHAR(250),

71. PKGINFO VARCHAR(250),

72. PRICE REAL NOT NULL,

73. COST REAL NOT NULL,

74. CATEGORY INTEGER NOT NULL,

75. QUANTITY INTEGER NOT NULL,

76. SELLDATE VARCHAR(250),

77. ORDER_ORDERID VARCHAR(250) NOT NULL

78. );

80. ALTER TABLE ORDERITEM

81. ADD CONSTRAINT PK_ORDERITEM PRIMARY KEY (INVENTORYID, ORDER_ORDERID);

83. CREATE TABLE IDGENERATOR(

84. IDNAME VARCHAR(250) NOT NULL,

85. IDVALUE INTEGER NOT NULL

86. );

88. ALTER TABLE IDGENERATOR

89. ADD CONSTRAINT PK_IDGENERATOR PRIMARY KEY (IDNAME);

91. CREATE TABLE BACKORDER(

92. BACKORDERID VARCHAR(250) NOT NULL,

93. INVENTORYID VARCHAR(250),

94. QUANTITY INTEGER NOT NULL,

95. STATUS VARCHAR(250),

96. LOWDATE BIGINT NOT NULL,

97. ORDERDATE BIGINT NOT NULL,

98. SUPPLIERORDERID VARCHAR(250) NULL

99. );

101. ALTER TABLE BACKORDER

102. ADD CONSTRAINT PK_BACKORDER PRIMARY KEY (BACKORDERID);

104. CREATE TABLE SUPPLIER(

105. SUPPLIERID VARCHAR(250) NOT NULL,

106. NAME VARCHAR(250),

107. STREET VARCHAR(250),

108. CITY VARCHAR(250),

109. USSTATE VARCHAR(250),

110. ZIP VARCHAR(250),

111. PHONE VARCHAR(250),

112. URL VARCHAR(250)

113. );

115. ALTER TABLE SUPPLIER

116. ADD CONSTRAINT PK_SUPPLIER PRIMARY KEY (SUPPLIERID);

Comme on peut le voir, le schéma de la base de données n'est pas ce qui se fait de mieux, mais nous permettra d'avoir une bonne vision de l'utilisation de Benerator.

Après la découverte du schéma de la base de données et du fonctionnement Benerator, regardons comment créer le fichier XML de description du projet.

II-B - Paramétrage de la base de données cible et de la volumétrie du jeu de données

Mais avant cela, nous allons créer deux fichiers properties afin de regrouper les informations sur :

- la base de données ;

- la volumétrie cible.

Les informations sur la base de données seront dans le fichier mysql\PlantsByWebSphere.mysql.properties

1. bddUrl=jdbc:mysql://localhost:3306/test

2. bddDriver=com.mysql.jdbc.Driver

3. bddCatalog=test

4. bddUser=root

5. bddPassword=mysql

Les informations sur les volumétries cibles seront dans les fichiers de type PlantsByWebSphere.{volumetrie}.properties

Par exemple pour un poste de développement, le fichier se nommera PlantsByWebSphere.development.properties

1. taillePaquet=10

2. customer_count=10

3. inventory_cat0_count=10

4. inventory_cat1_count=3

5. inventory_cat2_count=2

6. inventory_cat3_count=5

7. supplier_count=1

8. order_count=60

9. items_per_order=3

II-C - Création du fichier de description de Benerator

- Commençons par l'entête du fichier.

1. <!--?xml version="1.0" encoding="iso-8859-1"?-->

- Importons les domaines nécessaires et la bonne plate-forme.

Définissons des valeurs par défaut pour le type de volumétrie et le type de base de données cible.

Valeur par défaut

- Chargeons les deux fichiers properties que l'on a créés.

Récupération des valeurs pour la volumétrie et la base de données cible

- Définissons l'URL de la base de données (ne pas oublier d'ajouter les drivers dans le classpath si nécessaire).

Afin d'éviter les mauvaises surprises, partons d'une base vide (drop + create) à l'aide de deux scripts SQL.

Drop des tables avant leurs créations

- Créons deux générateurs de nombres auto-incrémentés pour les utiliser comme clé primaire. Maintenant, en fonction de ce que l'on veut tester, il nous reste plusieurs choix possibles comme :

- simuler des tests avec un catalogue de produits plus grand que celui défini par défaut ;

- simuler des tests à l'ouverture de la boutique en ligne ;

- simuler des tests après plusieurs jours de fonctionnement (ce qui correspond à avoir déjà des clients et des commandes en base de données) ;

- simuler plusieurs combinaisons des cas précédents.

Ces choix impacteront le volume et la répartition des données en base et donc les résultats des tests.

Dans notre cas, nous allons regarder comment créer des données pour chaque table.

- Commençons par ajouter des articles en base (table INVENTORY).

Chargeons les images des articles en mémoire afin de pouvoir remplir le champ IMGBYTES. L'objectif du jeu de données étant une campagne de tests de charge, nous ne nous soucierons pas de la correspondance entre l'image et le produit.

Afin de contrôler le plus finement possible la répartition des articles, nous les traiterons catégorie par catégorie (champ CATEGORY).

Chaque catégorie sera générée de cette façon (ici pour la catégorie des Flowers)

1. generate type="INVENTORY" count="{inventory_cat0_count}" consumer="db" pageSize="{taillePaquet}" >

En fonction de la catégorie et de l'objectif du test, on pourra modifier les paramètres suivants :

- count ;

- QUANTITY ;

- ISPUBLIC.

Je vous laisse créer les autres articles pour les trois catégories restantes (CATEGORY aura pour valeurs : 1, 2 et 3).

- Créons à l'identique de l'original la table SUPPLIER.

- Créons des comptes clients (table CUSTOMER). Comme on peut le voir, on utilise les domaines Personet Address afin d'avoir des données réalistes.

Il nous reste à créer des commandes clients (tables ORDER1, ORDERITEM et IDGENERATOR).

- Remplissons la table ORDER1.

- Puis la table ORDERITEM.

Mettons à jour le prix de chaque commande (champ PROFIT de la table ORDER1).

On utilise la fonction SQL IFNULL de MySQL afin d'être sûr de mettre une valeur non null dans le champ PROFIT.

Une autre solution est d'utiliser un subSelector à la place de la combinaison de selector et cyclic="true".

Pour la dernière table IDGENERATOR, on va utiliser les capacités de Benerator à importer des fichiers CSV.

Importons le fichier CSV idgenerator.import.csv.

Puis mettons à jour la valeur du champ IDVALUE.

Une autre solution est de tout faire lors de l'importation du fichier CSV à l'aide du mot clé condition.

Il ne reste plus qu'à exécuter Benerator pour générer notre jeu de données.

Notre fichier XML de description est prêt et je vous laisse le paramétrer au mieux pour l'objectif de vos tests.

Ma conclusion sur cet outil est toujours la même :

- il est pratique ;

- pilotable en ligne de commande et donc très flexible pour son intégration dans un processus ;

- larges possibilités :

- générer un jeu de données à partir de rien ;

- anonymiser un jeu de données ;

- traitement de données existantes comme pour un ETL ;

- création de fichiers d'entrée pour un test de charge (création de login/password…) ;

- possibilité d'utiliser le même fichier XML de configuration de Benerator pour divers environnements (test, développement,préproduction …) à l'aide de fichiers properties ;

- documentation complète ;

- développement actif ;

- gratuit ;

- open source ;

- support par le développeur ;

- extensible.

III - Conclusion

Dans ce tutoriel, nous avons présenté l'outil Benerator. C'est un outil de génération de données open source, dont le but premier est de générer d'importants lots de données pour des tests.

Benerator génère des entités abstraites sur la base d'un fichier de configuration. Les formats suivants sont supportés comme sources de données pour la génération : Comma Separated Values (CSV), XML, flat file, database et Excel sheet.

IV - Remerciements

Nous tenons à remercier Claude Leloup pour sa relecture de cet article et Laethy pour la mise au gabarit.