• 8 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 27/09/2021

Découvrez Spring Boot Test et déployez votre projet

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Abordez la dernière étape : les tests et le déploiement

C’est ici la dernière ligne droite, et je sens l’adrénaline monter! 😃

Pour conclure notre application HelloWorld, il nous reste 2 choses à faire :

  1. Tester notre application.

  2. Déployer notre application.

Pas besoin de vous expliquer que les tests sont utiles, je suis convaincu que vous avez déjà conscience de leur importance.

“Déployer” revient à mettre en route notre application. Autrement dit, il s’agit de passer de l’environnement de développement à l’environnement de production.

Voyons tout ça dans le détail, c’est parti !

Découvrez Spring Boot Test

Je vous en ai parlé précédemment, lors de la création de la structure minimale du projet, une classe de test a été créée, à savoir HelloWorldApplicationTests.java. Allons la regarder de plus près ;-) !

package com.openclassrooms.helloworld;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class HelloworldApplicationTests {
@Test
void contextLoads() { }
}

Plutôt simple, n’est-ce pas ? Presque étonnant, d’ailleurs ! Expliquons.

@SpringBootTest est une annotation fournie par Spring Boot. Elle permet lors de l’exécution des tests d’initialiser le contexte Spring. Les beans de notre application peuvent alors être utilisés.

Rappelons qu’un test s’exécute de façon unitaire, presque comme une application à part entière. Par défaut, notre test n’a donc aucune connaissance du contexte Spring. Dans le cas d’une application Spring Boot, c’est un vrai problème !

Mais le problème est résolu grâce à l’annotation @SpringBootTest.

La méthode contextLoads est annotée @Test (annotation qui provient de JUnit ; quand je vous disais que d’autres frameworks utilisent les annotations 😉), et n’a pas de contenu.

Pourquoi n’a-t-elle pas de contenu ?

Tout simplement parce que son unique objectif est de vérifier que le contexte Spring se charge bien.

Sans méthode de tests (c’est-à-dire sans méthode avec @Test), notre classe de test ne peut être exécutée, même si elle est annotée @SpringBootTest. Pour parer à cela, Spring Boot génère une méthode vide annotée @Test, et qui sera donc toujours success pour JUnit (car elle est vide).

Ainsi, lors de l’exécution de cette méthode, le contexte Spring sera chargé, et si ce dernier rencontre une erreur, alors l’exécution de la classe de test retournera une erreur.

Très bien ! Maintenant, testons notre HelloWorld !

D’accord, mais on teste quoi ?

Le but de ce cours n’est pas de vous expliquer les méthodologies de test. Mais rappelez-vous toujours qu’au sein d’un projet, on va tester les traitements métiers pour s’assurer qu’ils correspondent bien aux attendus.

Dans notre cas, le traitement métier est représenté par la méthode getHelloWorld() de la classe BusinessService.

Donc, nous allons tester cette méthode.

Je vous laisse essayer, voici quelques indices :

  1. Ajoutez une nouvelle méthode de test.

  2. Injectez une instance de BusinessService dans la classe de test.

  3. Vérifiez que l’attribut “value” de l’objet HelloWorld contient bien le texte “Hello World!”.

Ensuite, il ne vous reste plus qu’à faire un clic droit sur la classe, “Run As”, “JUnit Test”.

La vue JUnit au sein de STS devrait ressembler à ça :

Les tests unitaires testGetHelloWorld() et contextLoads() ont été exécutés avec succès. La fenêtre JUnit indique un résultat de 2/2.
Fenêtre JUnit de l’IDE qui affiche le résultat des tests

Avez-vous réussi ? Super ! Félicitations :-)

Voici tout de même une correction :

package com.openclassrooms.helloworld;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import com.openclassrooms.helloworld.service.BusinessService;
@SpringBootTest
class HelloworldApplicationTests {
@Autowired
private BusinessService bs;
@Test
void contextLoads() {
}
@Test
public void testGetHelloWorld() {
String expected = "Hello World!";
String result = bs.getHelloWorld().getValue();
assertEquals(expected, result);
}
}

Analysons :

  • Lignes 14/15 : j’injecte une instance de BusinessService dans un attribut nommé bs. À noter que sans l’annotation @SpringBootTest, cela échouera car sans contexte Spring, impossible de faire de l’injection de dépendances.

  • Lignes 21/22 : j’écris ma méthode, sans oublier d’annoter @Test.

  • Ligne 24 : je définis le résultat attendu pour la valeur “Hello World!”.

  • Ligne 26 : je récupère, à travers l’instance du BusinessService, un objet HelloWorld, puis j’appelle la méthode getValue et affecte le résultat dans une variable nommée result.

  • Ligne 28 : grâce à assertEquals, je compare les 2 variables. Si elles sont égales, le test réussit, sinon il échoue.

Allez ! Passons au déploiement !

Découvrez les méthodes de déploiement

Notre objectif est désormais de déployer et ainsi d’exécuter notre application.

L’environnement de développement correspond généralement à notre IDE. Dans le cas de ce cours, on utilise STS.

L'environnement d'exécution peut varier. Il peut s'agit d'un environnement de tests ou d'un environnement de production. Notons que l’environnement de développement peut également être un environnement d’exécution.

Quel prérequis doit avoir un environnement d’exécution ?

Je suis sûr que vous connaissez la réponse : tout simplement une JRE, qui permet ainsi l’exécution d’un programme Java.

Même si c’est une application Spring, la simple JRE suffit ?

Tout à fait, et c’est une très bonne nouvelle ! Rappelons que parmi les avantages de Spring Boot, il y a sa facilité de déploiement car le JAR qui résulte de la compilation embarque tout.

Par exemple, même le serveur Tomcat qui permet d’exécuter une application web est embarqué. Nul besoin d’installer un serveur Tomcat, il est déjà là !

Voyons plusieurs méthodes pour déployer notre application via ce screencast :

Récapitulons les méthodes employées :

  1. À travers l’IDE avec “Run As”, “Spring Boot App”.

  2. Avec le goal Maven spring-boot:run.

  3. En exécutant le JAR grâce à la commande java -jar.

Nous sommes bien d’accord, le résultat est le même ! Gardons à l’esprit que dans un contexte professionnel, on livrera généralement un JAR, et c’est ce dernier qui sera exécuté.

Les méthodes de déploiement et d’exécution via l’IDE et Maven sont surtout utiles pour les développeurs.

En résumé

  • Spring Boot fournit une annotation @SpringBootTest qui permet de charger le contexte Spring lors de l’exécution des tests.

  • Déployer une application Spring Boot est très facile, car l’artefact qui en résulte est un simple JAR où tout est embarqué.

  • Il existe plusieurs méthodes pour exécuter notre application Spring Boot :

    • Via l’IDE directement.

    • Grâce à Maven et au goal spring-boot:run.

    • En exécutant la commande java -jar.

La partie 2 du cours touche à sa fin ! Qu'avez-vous retenu ? Connaissez-vous maintenant les étapes de tout projet Spring Boot ? C'est que vous allez voir avec le quiz ! 💪

Exemple de certificat de réussite
Exemple de certificat de réussite