Bootcamp

Exercice 1 - Git / Github

1. Créer un compte sur Github (si vous n'en avez pas déjà un)
   Comme on veut accéder à un repository Git chez Github à partir d'un terminal puis en utilisant IntelliJ, nous allons dans un premier temps générer une paire clé publique/clé privée pour utiliser le protocole SSH.
   Créer une paire de clé publique/clé privée avec ensuivant les explications https://docs.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent
   puis enregistrer la clé publique sur Github avec l'interface Web en suivant les explications https://docs.github.com/en/github/authenticating-to-github/adding-a-new-ssh-key-to-your-github-account
2. En utilisant l'interface Web de github, créer un repository nommé java-inside avec un .gitignore configuré pour les projets Java et un README indiquant que ce repository contient les sources des différents lab de la matière Java Inside.
3. Nous allons d'abord configurer git avec la commande git config sur votre machine ou à la fac.

       git config --global user.name 'Your Full Name'
       git config --global user.email 'your.name@host.com'
       git config --global core.editor 'vim'
      

4. Dans votre home directory, créer un répertoire nommé git qui va contenir l'ensemble des projets géré par Git. Puis dans ce répertoire, cloner le projet "java-inside "avec la commande git clone (dans un terminal) et l'addresse du projet disponible en utilisant l'interface Web (l'adresse doit commencer par git@ et pas https).
   Changer l'editeur de texte (pour le texte des commits) pour utiliser vi
   Modifier le README puis faite une git commit et aller vérifier que le README est bien mis à jour sur GitHub.
   Que se passe t'il ? Pourquoi ? Comment corriger le problème ?
5. Ajouter un fichier test.txt, puis utiliser git add. Puis faite en sorte que le fichier apparaisse sur Github.
6. Modifier le contenu du fichier test.txt en utilisant directement l'interface de github (le petit stylo Edit) pui commiter le.
   Comment faire pour mettre à jour la copie local de votre repository pour que vous voyez le contenu du fichier changé sur la machine locale.
7. Supprimer le fichier test.txt en locale et fait en sorte qu'il soit supprimer sur Github.
8. Prenez une feuille blanche et faire un dessin expliquant le fonctionnement de Git !

Exercice 2 - Maven et JUnit 5

1. Dans le répertoire java-inside, créer un fichier pom.xml avec le contenu suivant (utiliser vi, emacs, gedit, etc)
   

       <?xml version="1.0" encoding="UTF-8" standalone="no"?>
       <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
         <modelVersion>4.0.0</modelVersion>
         <groupId>fr.umlv.javainside</groupId>
         <artifactId>java-inside</artifactId>
         <packaging>pom</packaging>
         <version>1.0-SNAPSHOT</version>
         <name>java-inside</name>
       </project>
       

   
   le groupId correspond plus ou moins au package Java que l'on va utiliser, ici, fr.umlv.javainside, et l'artifactId au nom du projet, ici java-inside.
   Le fichier pom.xml que l'on vient de créer, contient les informations qui seront "hérité" dans les pom.xml des différents sous-modules, on appel ce fichier, le fichier pom-parent.
   Note: il est possible de créer directement un pom en lançant dans le répetoire git la commande

         mvn archetype:generate -DgroupId=fr.umlv.javainside  -DartifactId=java-inside -DinteractiveMode=false
       

   mais elle ne marche pas quand répertoire java-inside existe déjà :(
2. On veut maintenant générer le module correspondant au lab1. Dans le répertoire java-inside, utiliser la commande
   

        mvn archetype:generate -DgroupId=fr.umlv.javainside  -DartifactId=lab1 -DinteractiveMode=false
       

   
   Cette commande créé un sous-répertoire lab1 avec son propre pom.xml
   On peut noter deux choses, le pom.xml dans lab1 contient un section parent qui indique le pom-parent.

        <parent>
          <groupId>fr.umlv.javainside</groupId>
          <artifactId>java-inside</artifactId>
          <version>1.0-SNAPSHOT</version>
        </parent>
       

   Et le pom.xml parent a été mis à jour pour indiquer qu'il existe un module lab1.

        <modules>
          <module>lab1</module>
        </modules>
       

   
   En plus d'un pom.xml dans le bon répertoire, cette commande génère aussi deux fichiers .java de test dans src/main/java et dans src/test/java le premier étant le répertoire contenant les sources et le second étant le répertoire contenant les tests.
3. Dans IntelliJ, ouvrir en tant que projet le répertoire git/java-inside
   Dans File > Project Structure, configurer le projet pour utiliser "Java 17" et le langauge level "17 preview".
   Vous pouvez vérifier en cliquant sur "Modules" que IntelliJ a détecté que le projet était un projet Maven, composé de deux modules, le module parent "java-inside" et un sous-module "lab1".
   Vous pouvez aussi voir que dans le module lab1, IntelliJ à bien configuré le répertoire contenant les sources et le répertoire contenant les tests.
4. Supprimer dans le pom de lab1 la dépendance sur JUnit 3 car on va plutôt utiliser JUnit 5.
   Vous pouvez noter que quand vous changer un fichier pom.xml, IntelliJ vous met un icone M avec un rond de re-cyclage pour vous dire que comme le POM à changer il doit le re-charger, cliquer sur l'icone pour le recharger.
   Dans le pom-parent, ajouter les dépendences à JUnit 5

        <dependencies>
          <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.8.1</version>
            <scope>test</scope>
          </dependency>
          <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.8.1</version>
            <scope>test</scope>
          </dependency>
        </dependencies>
       

   
   On peut noter que JUnit 5 à jupiter comme nom de guerre et qu'il est plus propre que JUnit 3 (et 4) car il sépare l'engine qui exécute les tests de l'API qui permet de déclarer les tests (là où on va trouver l'annotation @Test et les méthodes assert...).
5. Il faut maintenant indiquer à Maven comment builder le projet "java-inside". Un build est un ensemble de plugins à exécuter, ici, le maven-compiler-plugin va faire la compilation Java et le maven-surefire-plugin va faire l'exécution des tests. Tous les plugings qui commence par "maven-" sont maintenus par l'équipe Maven mais il y a plein d'autre plugins pour Spring, Quarkus, etc
   

        <build>
          <plugins>
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.1</version>
              <configuration>
                <release>17</release>
              </configuration>
            </plugin>
   
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-surefire-plugin</artifactId>
              <version>3.0.0-M4</version>
            </plugin>
          </plugins>
        </build>
       

   
   Pour lancer Maven dans Intellij, cliquer sur le bonton "Maven" à droite de l'éditeur, puis "exécuter le maven goal" en cliquant sur le "m", puis taper

        mvn package
       

   ou

        mvn clean package
       

   car certains plugins génére des trucs dans le répertoire target et oublie d'effacer leurs trucs quand on recompile de nouveau.
   Normalement, vous devez avoir des warnings et une erreur, l'erreur est du au fait que dans lab1 on a un test écrit en JUnit 3 qui traine mais on a configuré dans le parent-POM une dépendance sur JUnit 5, donc cela marche pas bien. Le plus simple est de supprimer le test "AppTest" pour l'instant.
   Et maintenant cela devrait compiler normalement ! Mais il reste deux warnings, car on a pas dit à Maven que les fichiers Java sont encoder en UTF8, il suffit d'ajouter la propriété suivant (avant les dépendances, les dependencies) dans le parent-POM.

        <properties>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
       

   Normalement, si vous relancer Maven, les warnings ont disparus
6. Ajouter une interface Java fr.umlv.javainside.What dans le répertoire src/main/java du lab1 décrit par le code suivant
   

        public interface What {
          static String what(Object o) {
            return switch(o) {
                case String s -> "String " + s;
                case Integer i -> "Integer " + i;
                default -> throw new AssertionError("unknown type");
            };
          }
   
          static void main(String[] args) {
            System.out.println(what("hello"));
            System.out.println(what(3));
          }
        }
       

   
   Malheureseument, la pahse de compilation de Maven ne marche plus, les switchs sur des types sont une preview feature de Java, il va falloir expliquer à Maven, ou plutôt au plugin maven-compiler-plugin et au plugin maven-surefire-plugin qu'il faut accepter les preview feature.
   Je pourrais vous dire comment faire mais je vous laisse faire les recherche Google correspondante :)
   Note: le but est pas de demander à son camarade comment on fait, mais de le faire vous même, pour avoir une idée de comment un fichier pom.xml marche !
7. On souhaite ajouter une classe de test fr.umlv.javainside.WhatTest dans le répertoire src/test/java, utilisant JUnit 5, et écrivez plusiuers tests qui tests la méthode what (tester aussi les exceptions).
   Pour cela, metter le curseur sur l'interface What et presser les touches ALT-ENTER qui veut dire trouve moi un truc intelligent à faire ici (c'est l'équivalent de CTRL+1 de Eclipse).
   Si vous ne savez pas comment marche JUnit 5, vous pouvez regarder le guide de JUnit 5.

Exercice 3 - Github Action

1. Créer une Github Action de demo
2. Remplacer le fichier github-actions-demo.yml par un fichier maven.yml qui exécute la commande mvn après avoir downloadé le bon JDK en utilisant l'action actions/setup-java-jdk.
   Faite attention à ce que les tests que vous avez créer s'exécute correctement.
3. Pour les plus balèzes, mettez en place le SonarQube Scanner et faite en sorte qu'il soit exécuté par votre CI.