Jaxrs client avec Jersey

Ce n'est souvent pas évident de trouver un client Jaxrs. Jersey vous en propose un, et voici comment l'utiliser.  Par défaut j'ai rajouté les logs des requêtes HTTP :

  @Grab('com.sun.jersey:jersey-client:1.8')
  @Grab('com.sun.jersey:jersey-core:1.8')
  @Grab('com.sun.jersey.contribs:jersey-apache-client4:1.8')

  import com.sun.jersey.api.client.*;
  import com.sun.jersey.api.client.filter.LoggingFilter;
  import javax.ws.rs.core.*;
  import com.sun.jersey.client.apache4.ApacheHttpClient4;

  Client client = ApacheHttpClient4.create();
  client.addFilter(new LoggingFilter());
  def resource = client.resource("http://geek-du-soir.blogspot.com").path("/feeds/posts/default")
  resource.accept("application/xml+atom").get(String.class);

Maven : créer un projet multi-module

Maven, le très célèbre outil de build et gestionnaire de dépendances nous offre quelques possibilités bien sympatique.

Vous connaissez sûrement les projets multi-modules, qui permettent de découper un projet pour plus de modularité.

Par exemple vous construisez un projet P. Ce projet est constitué de plusieurs sous-projet A, B, C ayant comme dépendances respectives :

P :
  - A (A1, O)
  - B (O)
  - C (C1, A)

Comme vous le voyez, C dépend de A, mais pas de B. De plus la dépendance O est partagée entre plusieurs sous-projet.

Maven va bous permettre de gérer ses trois sous projet en réduisant le nombre de lignes de code copiées collées.



Voici le pom de P, le projet coordinateur :

<project ....>

    <groupId>org.groupId</groupId>
    <artifactId>P</artifactId>
    <packaging>pom</packaging>
    <version>1.0.0</version>
    <modelVersion>4.0.0</modelVersion>
    
    <modules>
        <module>A</module>
        <module>B</module>
        <module>C</module>
    </modules>
</project>

Il faut remarquer deux choses :
 
  - le packaging == pom, qui nous dit que ce projet n'aura pas de code source
  - la section modules qui représente notre structure.


Ensuite à la racine de ce projet, nous allons créer les 3 sous projets : A, B, C

/my-project
|--pom.xml
|--A
|  `--pom.xml
|--B
|  `--pom.xml
`--C
   `--pom.xml     

Voici le pom du sous-projet A  :

<project ...>
    <parent>
        <artifactId>P</artifactId>
        <groupId>org.groupId</groupId>
        <version>1.0.0</version>
    </parent>
    
    <modelVersion>4.0.0</modelVersion>
    <artifactId>A</artifactId>
    
....

Dans la balise parent, on défini la dépendance vers notre projet parent P.

Nous remarquons que pour A, il n'y a pas de balise groupId ni de balise version à définir A.
En effet, ces valeurs sont héritées du pom parent, pratique !!!!



Maintenant prenons le cas où certains sous-projets aient des dépendances en commun. A et B dépendent de O.

On pourrait tout a fait déclarer dans A et dans B les dépendances complètes (avec la version) :

<dependencies>
    <dependency>
        <groupId>com.aProject</groupId>
        <artifactId>O</artifactId>
        <version>5.6.7</version>
    </dependency>
</dependencies>

Mais le jours, on l'on changera la version de O ( 5.6.7 ---> 5.6.8 ) dans A, on oubliera sûrement de changer la version de O dans B, et l'on se retrouvera avec un pom dégelasse avec plein de dépendances différentes.

La solution consiste donc à ne pas déclarer les versions dans les poms des sous-projets, mais dans le pom parent.


Je vous donne un exemple :

<project ....>

    <groupId>org.groupId</groupId>
    <artifactId>P</artifactId>
    <packaging>pom</packaging>
    <version>1.0.0</version>
    <modelVersion>4.0.0</modelVersion>
    
    <modules>
        <module>A</module>
        <module>B</module>
        <module>C</module>
    </modules>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>2.0.1</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.8.2</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

Dans le pom d'un sous-projet, la section de dépendance ressemblera à :

<dependencies>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Cool, on a supprimé la version !!!!



Maintenant voyons le cas où C dépend de A, c'est à dire étudions les dépendances entre sous-projets.

Voici la section de dépendance de C :

<dependencies>
    ....
    <dependency>
        <groupId>${parent.groupId}</groupId>
        <artifactId>A</artifactId>
        <version>${parent.version}</version>
    </dependency>
    ....
</dependencies>

On est obligé de spécifier la version, mais regardez bien, nous faisons référence à une variable interne : ${parent.version}, de même pour la balise groupId. Zéro problème pour maintenir ce pom !!!


Et maintenant nous pourrions avoir envie de créer nos propres variables dans le pom parent et d'utiliser n'importe où.
Aussitôt dit, aussitôt fait. Editez votre pom parent et ajoutez la section :

<properties>
    <foo.bar>FooBarValue</foo.bar>
</properties>

Maintenant on peut utiliser cette valeur de partout ce cette façon : ${foo.bar}

Il y a bien sur une limite, la section parent ne peut être défini à partir de variable défini dans le pom parent. Sinon ce n'est pas évident pour deviner qui est le parent quand on lit le pom d'un sous-projet.

JAVA et Groovy

Groovy est un langage de programmation, basé sur Java et s'intégrant très bien avec tout son écosystème.

Pour vanter quelques mérites de Groovy voici des exemple Groovy VS Java :

JAVA
--------
String name = "World"
System.out.println("Hello " + name);

GROOVY
-----------
def name = "World"
println "Hello $name"


JAVA
--------
Map<String, String> params = new HashMap<String, String>();
params.put("key", "value")
System.out.println(params.get("key"))

GROOVY
-----------
def params = [key: "value"]
println params.key



JAVA
--------
public class Customer {

    private String name;

    private int age;

    Customer() {
    }

    Customer(String name, int age) {
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Customer customer = (Customer) o;

        if (age != customer.age) return false;
        if (name != null ? !name.equals(customer.name) : customer.name != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Customer toto = new Customer("Toto", 7);

        Customer toto2 = new Customer();
        toto2.setName("Toto");
        toto2.setAge(7);

        System.out.println(toto.equals(toto2));
    }
}


GROOVY
-----------
import groovy.transform.* 

def toto = new Customer(name: 'Toto', age: 7)

def toto2 = new Customer()
toto2.name = 'Toto'
toto2.age = 7

assert toto == toto2

@ToString 
@EqualsAndHashCode 
class Customer{

  String name

  int age


}​

Comme vous le voyez, Groovy permet d'avoir une syntaxe bien plus concise que l'équivalent en Java.

Moins de code à écrire == plus facile à développer == plus facile à lire (une fois que l'on a l'habitude) == plus facile à maintenir...

Et la liste est longue des Groovyness utilisables : 

  - la gestion des collections : filtrage, trie, modification, .... (simplifié grâce à la programmation fonctionnelle) : http://groovy.codehaus.org/Collections

  - la gestion des dates : http://groovy.codehaus.org/JN0545-Dates

  - la création de script dépendant de librairies présent sur Maven : http://groovy.codehaus.org/Grape

  - éviter les null pointer exceptions avec les opérateurs ?. et ?: : http://docs.codehaus.org/display/GROOVY/Operators#Operators-ElvisOperator%28%3F%3A%29

  - la création de mock : http://groovy.codehaus.org/gapi/groovy/mock/interceptor/MockFor.html

  - les mixins : http://groovy.codehaus.org/Category+and+Mixin+transformations

  - le meta-programming : http://groovy.codehaus.org/Per-Instance+MetaClass

  - les regex : http://groovy.codehaus.org/Regular+Expressions

  - la gestion des fichiers : http://groovy.codehaus.org/JN2015-Files

  - un vrai switch case : http://groovy.codehaus.org/Logical+Branching

  - toute les exceptions sont gérées comme des RuntimeException

  - ...

Groovy est un langage qui évolue vite, actuellement nous sommes à la version 1.8. Cette version ci rajoute un certain nombre de fonctionnalités intéressantes comme le support natif du JSON, l’annotation @Log qui permet d'injecter un logger (slf4j, log4j, ...), @ToString et @EqualsAndHashCode que je viens de vous montrer et encore pleins d'autres choses merveilleuses à découvrir ici : http://docs.codehaus.org/display/GROOVY/Groovy+1.8+release+notes

Depuis plus d'un an que j'utilise groovy tous les jours, je n'ai toujours pas rencontré de bug. Nous l'avons utilisé pour des scripts, des tests et des applications en production (http://www.grails.org/). C'est un langage que je recommande vraiment. Pour un développeur Java, c'est vraiment une bouffé d'air frais.

Il n'y a pas que des avantages, Groovy est lent, mais je trouve que le temps gagné lors de la phase de développement en vaut la chandelle.

Groovy est dynamique et n'est pas fortement typé, ce qui nécessite d'écrire plus de test unitaire. C'est peut être là sont plus gros défaut. 

Néanmoins, ces problèmes disparaîtront peut être un jours car les performance de Groovy ne font que s'améliorer avec le temps. De plus groovy++ est un projet prometteur car il ajoute un typage statique et des performances équivalentes à celles de Java. Mais je ne l'ai encore jamais testé.

L'intégration avec les IDE n'est pas forcement parfaite : 

  Netbeans -> moyen, 

  IntelliJ -> excellent, équivalent à Java

Mais l'integration avec Maven ne pose aucun problème : http://docs.codehaus.org/display/GMAVEN/Building+Groovy+Projects

Concernant les tests je conseille le framework Spock, sinon un simple JUnit fait très bien l'affaire. Pour du BDD, on peut utiliser EasyB, mais je préfère quand même Spock.

Come Java, Groovy ne favorise pas l'immutabilité (contrairement à scala) est c'est bien dommage pour les applications multi-threadées.

GPars a été intégré avec Groovy depuis la version 1.8 pour simplifier la programmation multi-threadée, mais j'ai encore un peu de mal à l'utiliser. Je ne trouve pas l'API intuitive. Mais bon je vais surement m'y habitué.

Pour avoir également testé Scala quelques jours, Groovy est peut être moins puissant mais est plus facile à prendre en main lorsque l'on est habitué à Java. Mais Scala semble quand même plus robuste et plus simple pour tout ce qui concerne le développement d'applications multi-threadées, tolérantes aux pannes et scalable  : http://akka.io/

TopCoder Arena

Ce soir je vais sur le site de recrutement de Google, et dans la section Préparation de l'entretien, Google nous conseil de s’entraîner sur TopCoder Arena.

Aller je tente.

Après un processus d'enregistrement super chi..., où l'on me demande ma couleur de peau (merci les Etats-Unis) je peux enfin avoir des accès.

Top Coder Arena est une Applet Java qui affiche des problèmes informatiques à résoudre. On se croirait en cours pendant un TD d'info. L'appli permet de compiler et de tester son code avant de le soumettre.

J'ai commencé facile avec un problème à 150 points. Je vous le donne :

Problem Statement
    
***Note:  Please keep programs under 7000 characters in length.  Thank you


Class Name: HowEasy
Method Name: pointVal
Parameters: String
Returns: int
 
TopCoder has decided to automate the process of assigning problem difficulty
levels to problems.  TopCoder developers have concluded that problem difficulty
is related only to the Average Word Length of Words in the problem statement:

If the Average Word Length is less than or equal to 3,  the problem is a 250
point problem.
If the Average Word Length is equal to 4 or 5, the problem is a 500 point
problem.
If the Average Word Length is greater than or equal to 6, the problem is a 1000
point problem.
 
Definitions:
Token - a set of characters bound on either side by spaces, the beginning of
the input String parameter or the end of the input String parameter.
Word - a Token that contains only letters (a-z or A-Z) and may end with a
single period. A Word must have at least one letter.
Word Length - the number of letters in a Word. (NOTE: a period is NOT a letter)

The following are Words :
"ab",  "ab."

The following are not Words :
"ab..", "a.b", ".ab", "a.b.", "a2b.", "."

Average Word Length - the sum of the Word Lengths of every Word in the problem
statement divided by the number of Words in the problem statement.  The
division is integer division. If the number of Words is 0, the Average Word
Length is 0.
 
Implement a class HowEasy, which contains a method pointVal.  The method takes
a String as a parameter that is the problem statement and returns an int that
is the point value of the problem (250, 500, or 1000). The problem statement
should be processed from left to right.
 
Here is the method signature (be sure your method is public):
int pointVal(String problemStatement);
 
problemStatement is a String containing between 1 and 50 letters, numbers,
spaces, or periods.  TopCoder will ensure the input is valid.
 
Examples:
 
If problemStatement="This is a problem statement", the Average Word Length is
23/5=4, so the method should return 500.
If problemStatement="523hi.", there are no Words, so the Average Word Length is
0, and the method should return 250.
If problemStatement="Implement a class H5 which contains some method." the
Average Word Length is 38/7=5 and the method should return 500.
If problemStatement=" no9 . wor7ds he8re. hj.." the Average Word Length is 0,
and the method should return 250.
Definition
    
Class:            HowEasy
Method:           pointVal
Parameters:       String
Returns:          int
Method signature: int pointVal(String param0)
(be sure your method is public)
    

Et je vous donne ma solution.

import java.util.regex.*;

public class HowEasy{
  
  Pattern regex = Pattern.compile("[a-zA-Z]+\\.?$");
  
  public int pointVal(String problemStatement){
    String[] words = problemStatement.split(" ");
    int matchingWords = 0;
    int wordLength=0;
    for(String word: words){
      Matcher m =regex.matcher(word);
      if(m.matches()){
        matchingWords++;
        wordLength+=word.length();
      }
      
      
    }
    
    if(matchingWords==0) return 250;
    
    int avgWordLength = wordLength / matchingWords;
    if(avgWordLength<=3){
      return 250;
    }else if(avgWordLength==4){
      return 500;
    }else if(avgWordLength==5){
      return 500;
    }else{
      return 1000;
    }
    
    
  }

}

150 points / 250, c'est pas terrible, je peux mieux faire.
Je pense que j'ai oublié d'enlever les points pour calculer la longueur des mots.

A vous !!!

Dig en Java

DNSJava est une API JAVA permettant de faire des résolutions de domaines.

DNSJava offre également une implémentation équivalente à dig (voir les sources)

Si vous souhaitez parser le contenu d'un DIG en Java pour récupérer les IPs des serveurs, je vous conseil plutôt d'utiliser l'API de DNSJava.
Vous aurez une représentation objet du DIG qui vous permettra de ne récupérer que ce qui vous intéresse vraiment.

Voici un exemple écrit en groovy qui fait l'équivalent d'un 'dig google.com'

    import org.xbill.DNS.*;

    @Grab(group='dnsjava', module='dnsjava', version='2.1.1')

    SimpleResolver res = new SimpleResolver();
    Record rec = Record.newRecord(Name.fromString("google.com", Name.root), Type.A, DClass.IN);
    Message query = Message.newQuery(rec);
    Message response = res.send(query);
    println("----------------------------------------------------------");
    for (Record record : response.getSectionArray(1)) { // ANSWER SECTION
      println(record.rdataToString());
    }
    println("----------------------------------------------------------");
    println(response.toString()); //THE WHOLE DIG

Et voici le résultat affiché :

    --------------------------------------------------------
    209.85.227.106
    209.85.227.103
    209.85.227.105
    209.85.227.104
    209.85.227.99
    209.85.227.147
    --------------------------------------------------------
    ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 53158
    ;; flags: qr rd ra ; qd: 1 an: 6 au: 0 ad: 0 
    ;; QUESTIONS:
    ;; google.com., type = A, class = IN

    ;; ANSWERS:
    google.com.  300 IN A 209.85.227.106
    google.com.  300 IN A 209.85.227.103
    google.com.  300 IN A 209.85.227.105
    google.com.  300 IN A 209.85.227.104
    google.com.  300 IN A 209.85.227.99
    google.com.  300 IN A 209.85.227.147

    ;; AUTHORITY RECORDS:

    ;; ADDITIONAL RECORDS:

    ;; Message size: 124 bytes

Grails thumbnail : Reduire une image dans grails en gardant une bonne qualité

En java ce n'est pas forcement facile de trouver une librairie pour réduire des images en gardant une bonne qualité.

Heureusement il existe le projet Java Image Scaling qui a sa librairie sur maven.
http://code.google.com/p/java-image-scaling/


Maintenant voici comment intégrer Java Image Scaling dans grails : un jeu d'enfant :)

Ajouter la dépendance suivante dans grails-app/conf/BuildConfig.groovy

runtime 'com.mortennobel:java-image-scaling:0.8.5'

Dans votre controller ajoutez le bout de code suivant :

  /**
   * Return the content of screen shot
   */
  def viewScreen = {
    File img = new File("myImage.png")
    response.contentType = 'image/png'
    if(params.thumbnail){
      BufferedImage inputImage = ImageIO.read(img);
      BufferedImage rescaledImage = new MultiStepRescaleOp(DimensionConstrain.createMaxDimension(355,500)).filter(inputImage, null);
      def outputStream = new ByteArrayOutputStream()
      ImageIO.write(rescaledImage, "png", outputStream);
      response.outputStream << outputStream.toByteArray()
    }else{
      response.outputStream << img.bytes
    }
  }

Rechercher dans Maven Central

Nous avons souvent besoin de rechercher des dépendances pour les inclure dans nos projets maven.

Le problème c'est que maven central est un peu gros. Sonaytype nous dis en 2010 :
"the Central Maven repository contains almost 90000 software artifacts occupying around 70 GB of disk"

Pour trouver nos petits, soit on navigue à la main dans l'arborescence de maven central :
http://repo1.maven.org/maven2/
http://repo2.maven.org/maven2/

Soit on utilise des outils de recherche. J'en connais deux :
  - http://mavencentral.sonatype.com/ : Qui utilise l'indexer maven, open sourcé par sonatype (Cf : http://www.sonatype.com/people/2011/02/maven-indexer-sonatypes-donation-to-repository-search/)

  - http://mvnrepository.com


Je trouve http://mavencentral.sonatype.com/ intéressant car il nous montre si les sources et la javadoc sont téléchargeable via maven.

Quand à http://mvnrepository.com, c'est celui que j'utilise depuis toujours :). Il est bien, mais il génère beaucoup plus de résultats parasites. Par contre il permet une navigation via les dépendances et via les usages.

Serveur REST avec JAXRS + Basic Auth + SSL avec Restlet

J'avais un peu galéré pour mettre en place un serveur webservice REST avec authentification basic et chiffrement  SSL en java.

L'authentification basic transmettant le login et le mot de passe en clair, il est indispensable de l'utiliser via une connexion chiffré (HTTPS).

JAX-RS est l'un des standard pour faire des web-services JAVA :

• JAX-RS = JSR311 pour les webservices REST
• JAX-WS = JSR 224 pour les webservices SOAP

En dehors des standards il existe un certain nombre de frameworks pour faire des web-services REST en JAVA :

• http://www.restlet.org/
• http://www.jboss.org/resteasy/docs.html
• http://jersey.java.net/
• https://github.com/jacek99/Napalm

A l'époque j'était parti sur une base CXF, mais la documentation n'étais pas très abondante.

Ensuite j'ai migré sur Restlet. La solution n'a pas été très évidente à trouver, mais ça marche.

Voici la solution (pour les plus pressés):
https://github.com/Filirom1/JAX-RS-Server/blob/master/src/main/java/org/filirom1/jaxrs/JAXRSServer.java


Maintenant, si vous ne voulez pas vous prendre la tête, voici une API plus simple d'utilisation :

JAXRSServer server = new JAXRSServer(MyResource.class, 8443);
server.enableBasicAuthentication("Realm", "login", "password");
server.enableSSL("www.hostname.fr", new File("path-to-your-keystore.jks"), "keyStorePassword", "keyPassword");
try {
    server.start();

    /* do what you have to do */

    server.stop();
} catch (Exception ex) {
    Assert.fail("Unable to start", ex);
}

Et voici un exemple de Resource JAX-RS qui affiche un hello world :

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;

@Path("/")
class MyRessource{

    @GET
    @Produces("text/plain")
    public String getPlain() {
        return "Hello world)";
   

Et pour les utilisateurs de maven, voila comment inclure cet API dans votre pom.xml :

<dependencies>
...
    <dependency>
        <groupId>org.filirom1</groupId>
        <artifactId>JAX-RS-Server</artifactId>
        <version>1.0.0</version>
        <type>jar</type>
    </dependency>
...
</dependencies>
<repositories>
    <repository>
        <id>filirom1-repo</id>
        <url>https://Filirom1@github.com/Filirom1/filirom1-mvn-repo/raw/master/releases</url>
    </repository>
    <repository>
        <id>maven-restlet</id>
        <url>http://maven.restlet.org</url>
    </repository>
</repositories>

https://github.com/Filirom1/JAX-RS-Server

Juste pour le fun, j'utilise Resty comme client Webservice REST.

Il est simple d'utilisation et léger (0 dépendance externe).

Voici un exemple pour faire un GET avec authentification basic :

Resty r = new Resty();
r.authenticate("https://localhost:8443", "login", "password".toCharArray());
String resp = r.text("https://localhost:8443").toString();

Si vous avez des problèmes avec votre client REST avec les certificats auto-signés, je vous conseil le code de Francis Labrie :

http://en.wikibooks.org/wiki/WebObjects/Web_Services/How_to_Trust_Any_SSL_Certificate

• SSLUtilities.trustAllHostnames() pour désactiver la vérification du hostname pour les connexion HTTPS
• SSLUtilities.trustAllHttpsCertificates() pour désactiver la vérification du certificat pour les connexions HTTPS

Et si vous ne savez encore comment générer un certificat auto-signé :

# Generate a Self-Signed Certificate #
keytool -genkey -v -alias localhost -dname "CN=localhost, OU=IT, O=MyCompany, L=Lyon, ST=France, C=FR" -keypass password -keystore localhost.jks -storepass password -keysize 1024;

# Export your certificate in order to import it in your trustore
keytool -storepass password -alias localhost -export -file localhost.cer -keystore localhost.jks

# Import your certificate into the default JAVA truststore.
sudo keytool -keystore /etc/java-6-sun/security/cacerts -storepass changeit -import -trustcacerts -v -alias localhost -file localhost.cer

https://github.com/Filirom1/JAX-RS-Server

Ou sinon, on peut également générer des certificats auto-signés avec maven (très pratique pour les tests) :

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>keytool-maven-plugin</artifactId>
    <executions>
        <execution>
    <phase>generate-resources</phase>
    <id>clean</id>
    <goals>
        <goal>clean</goal>
    </goals>
        </execution>
        <execution>
    <phase>generate-resources</phase>
    <id>genkey</id>
    <goals>
        <goal>genkey</goal>
    </goals>
        </execution>
    </executions>
    <configuration>
        <keystore>${project.build.directory}/localhost.jks</keystore>
        <dname>CN=localhost, OU=IT, O=MyCompany, L=Lyon, ST=France, C=FR</dname>
        <keypass>password</keypass>
        <storepass>password</storepass>
        <alias>localhost</alias>
        <keyalg>RSA</keyalg>
    </configuration>
</plugin>

https://github.com/Filirom1/JAX-RS-Server

Selenium 2 Webdriver rajouter des plugins à firefox

Selenium est un projet open source qui permet de contrôler des navigateurs (Firefox, IE, Chrome, ...).
Par exemple on peut lui dire :
  - tu ouvres l'url : http://google.fr
  - tu saisies le texte : 'bla bla' dans le champs de recherche
  - tu cliques sur le boutons 'Rechercher'
  - tu attends le chargement de la page
  - puis tu vérifies la présence d'un texte.

Actuellement Selenium et Webdriver de google sont en train de fusionner pour donner naissance à Selenium2. Actuellement nous sommes à la première version beta.

Selenium2 propose pas mal d'améliorations par rapport à Selenium 1. De tête je peux citer :
   - le support des navigateurs Iphone, Android
   - un meilleur support des navigateurs Chrome, Firefox et IE
   - la possibilité de simuler un navigateur avec HTML Unit (toujours plus rapide que de lancer un Firefox)
   - et également la possibilité de rajouter des plugins et de configurer facilement le navigateur ( about: config sous Firefox)

Voici un exemple issue d'un projet open source qui rajoute à firefox le plugin firebug et qui désactive le cache de firefox.

private static FirefoxProfile tweakProfile(FirefoxProfile profile) 
{
  try {
  /* Load Firebug plugin */
  profile.addExtension(FirefoxProfile.class, "/firebug-1.5.4.xpi");
  /* Disable the cache of Firefox */
  profile.setPreference("browser.cache.disk.enable", false);
  profile.setPreference("browser.cache.memory.enable", false);
  profile.setPreference("browser.cache.offline.enable", false);
  profile.setPreference("network.http.use-cache", false);

} catch (IOException e) {
  throw new RuntimeException("Could not load required extensions,
     something is wrong", e);
}
return profile;
}
Voir les sources : HTML to HAR

La commande ci dessous permet de rajouter des plugins à Firefox :

profile.addExtension(FirefoxProfile.class, "/firebug-1.5.4.xpi"); 

Et cette commande là permet de modifier les préférences de firefox (équivalent à un about:config ) : 
profile.setPreference("browser.cache.disk.enable", false);