TP 3 : Travailler en équipe sur un depôt github distant

Retour à la page principale

Il est temps de commencer à utiliser git pour le travail d’équipe. En fait, git a été initialement conçu dans ce but et c’est là qu’il peut nous montrer sa puissance.

Avant de continuer, nous allons nous organiser en binômes. Si vous êtes un nombre impair, un équipe peut être composé de trois personnes malgré le TP est conçu pour deux roles.

Êtes-vous déjà constitué en équipe ? Lancez une pièce et décidez qui assumera le rôle de Athos et qui assumera le rôle de Porthos pour ce travail pratique. Si vous êtes trois, deux personnes seront regroupées dans le rôle d’Athos.

Objectifs du TP 3

Le but de ce troisième TP est de commencer à travailler en équipe sur github et développer un marché pour le projet de crypto-monnaie que nous avions déjà lancé. Dans ce TP, nous allons apprendre à :

Inviter des collaborateurs dans un dépôt personnel

Développement d’un projet java en équipe

Gérer des nouvelles fonctionnalités à l’aide des branches

Haut de la page

1. Inviter des collaborateurs dans un dépôt personnel

Athos :

Pour commencer, Athos va créer un nouveau dépôt dans son compte github appelé tp3 (Porthos fera bien de regarder et de commenter avec Athos comment cela est fait). Nous allons remplir le formulaire de la même manière que nous l’avons fait avec le dépôt tp2.

Une fois le dépôt créé, cliquez sur Settings :

ensuite sur Manage access et puis sur Invite a collaborator :

demandez à Porthos son nom d’utilisateur sur github et invitez-le dans votre dépôt :

Manage access

Porthos :

Porthos doit aller dans sa boîte email pour recevoir l’invitation d’Athos à collaborer dans le dépôt tp3 et l’accepter.

Athos et Porthos :

Chacun de vous peut faire un clone du projet en se plaçant dans le répertoire courseGIT :

$:~/courseGIT> git clone git@github.com:<utilisateur_de_athos>/tp3.git

Si vous l’avez bien fait, votre répertoire courseGIT devrait contenir trois répertoires comme indiqué ci-dessous :

$:~/courseGIT> ls
tp1 tp2 tp3

Exercices

Porthos : allez dans le répertoire tp3 et mettez à jour tous les fichiers avec ceux du répertoire tp2 (README.md et src/Cryptomonnaie.java) (surtout ne copiez pas le répertoire caché .git). Synchronisez les dépôts local et distant.

Athos : après que Porthos vous en informe, faissez un git pull depuis votre répertoire local tp3 pour synchroniser les changements.

Les deux : vérifiez que tous les dépôts sont bien synchronisés (ce qui est sur github correspond bien à ce que vous avez dans votre répertoire local).

Haut de la page

2. Développement d’un projet java en équipe

Git a été principalement conçu pour gérer le travail en équipe. Revenons au projet Crypto-monnaie pour lequel nous allons créer un marché avec différents portefeuilles. Avant de commencer, décrivons certains concepts :

Portefeuille :

Un portefeuille cryptographique est un portefeuille virtuel dans lequel un utilisateur peut stocker un certain nombre de jetons d’une crypto-monnaie. Cet utilisateur peut posséder plusieurs portefeuilles, mais chaque portefeuille ne peut contenir qu’un seul type de crypto-monnaie. Un portefeuille permet des achats de jetons ainsi qu’un transfert de jetons entre portefeuilles si le type de crypto-monnaie est le même.

Marché :

Le marché est un registre avec une série de portefeuilles cryptographiques. En principe, le marché nous permet de poser certaines questions telles que quel est le capital total d’un utilisateur avec plusieurs portefeuilles ou quel est le capital total en circulation d’une crypto-monnaie spécifique.

Athos et Porthos :

Avant de continuer, assurez-vous que votre dépôt tp3 est parfaitement synchronisé.

Athos :

Copiez les fichiers suivants dans le répertoire tp3/src, validez-les dans le dépôt local et distant :
CryptoMarche.java
Portefeuille.java
TestCryptoMarche.java

Porthos :

Assurez-vous d’obtenir la dernière version du dépôt distant.

Athos et Porthos :

Votre mission sera de compléter la fonctionnalité qui manque pour compléter notre application de marché de crypto-monnaie. Porthos se concentrera sur l’implementation de la classe Portefeuille.java et Athos sur l’implementation de la classe CryptoMarche.java. L’objectif est de faire passer les tests décrits dans le fichier TestCryptoMarche.java (il n’est pas permis de modifier ce fichier).
Avant de continuer, compilez tout le code et assurez-vous qu’il n’y a pas d’erreurs de compilation.
Exécutez en ligne de commande java TestCryptoMarche. La réponse devrait être la suivante :

Test Portefeuille transfertDevise        ... FAIL
Test Portefeuille achatDevise            ... FAIL
Test CryptoMarche capitalEnEuros         ... FAIL
Test CryptoMarche capitalMonneaie        ... FAIL

Athos :

Votre tâche consiste à terminer l’implémentation des deux fonctions suivantes de la classe CryptoMarche.java. Suivez la spécification dans les commentaires pour les compléter. Une fois terminé, synchronisez vos modifications avec le dépôt local et distant.

    /**
     * Cette fonction recherche sur le marché tous les portefeuilles 
     * du propriétaire et calcule son capital en euros. 
     * @param proprietare
     * @return capital en euros du propriétare.
     */
    public double capitalEnEuros(String proprietaire){
        /**
			FONCTION À IMPLEMENTER
        **/
        return 0;
    }

    /**
     * Cette fonction recherche sur le marché tous les portefeuilles 
     * d'un type de devise et calcule le volume total de capital de 
     * cette devise sur le marché 
     * @param monnaie
     * @return capital total en circulation de la cryptomonnaie (en euros).
     */
    public double capitalMonneaie(Cryptomonnaie monnaie){
        /**
			FONCTION À IMPLEMENTER
        **/
        return 0;
    }

Porthos :

Votre tâche consiste à terminer l’implémentation des deux fonctions suivantes de la classe Portefeuille.java. Suivez la spécification dans les commentaires pour les compléter. Une fois terminé, synchronisez vos modifications avec le dépôt local et distant.

  /**
   * Cette fonction vous permet de transférer des devises du portefeuille actuel 
   * vers le portefeuille de destination pour le montant indiqué. Le type de devise 
   * (nom du Jeton) doit être le même entre les deux portefeuilles et le montant 
   * du portefeuille actuel doit être supérieur ou égal à celui indiqué.
   * @param destination 
   * @param montantJetons
   * @return true si la transaction a été effectuée, false sinon.  
   */
  public boolean transfertDevise (Portefeuille destination, double montantJetons){
      /**
           FONCTION À IMPLEMENTER
	  **/
      return false;
  }

  /**
   * Cette fonction vous permet d'acheter des jetons de la 
   * crypto-devise en fonction de leur valeur en euros. 
   * Le résultat est l'augmentation des jetons de la crypto-monnaie.
   * @param montantEuros Valeur d'achat en euros 
   * @return true si le montant en euros est supérieur ou égal à 0 
   */
  public boolean achatDevise (double montantEuros){
	/**
           FONCTION À IMPLEMENTER
	**/
    return false;
  }

Exercice

Réalisez les étapes précédentes. Une fois les dépôts synchronisés, Athos et Porthos doivent compiler et lancer le test java TestCryptoMarche. Le résultat doit être le suivant :

Test Portefeuille transfertDevise        ... OK
Test Portefeuille achatDevise            ... OK
Test CryptoMarche capitalEnEuros         ... OK
Test CryptoMarche capitalMonneaie        ... OK

Haut de la page

3. Gérer des nouvelles fonctionnalités à l’aide des branches

Après avoir lancé le projet commun de marché de la crypto-monnaie, Athos et Porthos décident de s’attaquer à de nouveaux projets séparément. En particulier, chacun d’eux décide de lancer sa propre crypto-monnaie, respectivement : la AthosCoin et la PorthosCoin. Afin d’intégrer ces devises dans le marché existant, nous allons utiliser le concept de branches git.

Jusqu’à présent, sans avoir besoin de le savoir, toutes les modifications que nous avons apportées au dépôt, nous l’avons fait sur une branche principale appelée main ou master (le nom dépend des paramètres de configuration ). Si vous tapez git branch, vous obtiendrez ce nom. Cependant, si vous souhaitez créer une nouvelle fonctionnalité dans votre code (pas forcément une fonctionnalité principale, mais une fonctionnalité supplémentaire), git vous permet de créer une nouvelle branche : une fourchette dans la séquence des changements.

3.1. Tester le concept de branche avec un exemple simple

Athos et Porthos :

Imaginons que nous voulions tester une nouvelle fonctionnalité dans notre projet que nous appellerons “test”. Cette fonctionnalité peut être intégrée directement dans la branche principale main (comme nous l’avons fait jusqu’à présent) ou nous pouvons la tester dans une branche séparée, vérifier si cela fonctionne puis l’intégrer dans la branche principale. Essayons ce deuxième cas.

Commençons par lister toutes les branches actuelles de notre dépôt avec git branch puis voyons le contenu de cette branche :

$:~/courseGIT/tp3> git branch
* main
$:~/courseGIT/tp3> tree
.
├── README.md
└── src
    ├── CryptoMarche.java
    ├── Cryptomonnaie.java
    ├── Portefeuille.java
    └── TestCryptoMarche.java

À l’aide de git log, nous pouvons également voir toutes les modifications que nous avons apportées jusqu’à présent. Passons certains paramètres à la commande pour la rendre plus lisible.

$:~/courseGIT/tp3> git log --graph --oneline --all --decorate --topo-order
* 922b42b (HEAD -> main) Adding CryptoMarche
* 177514f (origin/main, origin/HEAD) Starting tp3++
* e7820d8 Starting tp3
* 455453c Initial commit

Il est temps de créer une nouvelle branche que nous appellerons test. Utilisez la commande suivante :

$:~/courseGIT/tp3> git checkout -b test
Switched to a new branch 'test'

L’option -b nous permet de dire à checkout que nous allons créer cette nouvelle branche. checkout nous fait changer de branche et aller dans la branche test (toutes les modifications apportées à partir de maintenant ne modifieront pas la branche main mais la branche test). Pour nous assurer que nous sommes dans la branche test, tapez :

$:~/courseGIT/tp3> git branch
  main
* test

L’étoile * indique qu’il s’agit de la branche de travail actuelle. Si nous voulons basculer entre les branches, nous pouvons utiliser la commande git checkout <nom_branche>.
Commençons par créer un nouveau fichier “test.txt” dans la branche test. Pour cela tapez :

$:~/courseGIT/tp3> touch test.txt
$:~/courseGIT/tp3> ls
README.md  src  test.txt

Et puis validons ces changements dans le dépôt local :

$:~/courseGIT/tp3> git add test.txt
$:~/courseGIT/tp3> git commit -m "fonction de test ajoutée "

Oublions un instant la branche test et revenons à la branche principale main, puis tapez la commande ls:

$:~/courseGIT/tp3> git checkout main
$:~/courseGIT/tp3> ls
README.md  src

Que se passe-t-il? Où est passé le fichier test.txt ?

Imaginez que nous suivions le développement au sein de la branche principale. Pour simuler cela, modifiez le fichier README.md en ajoutant la ligne: “Nous avons maintenant créé une nouvelle branche de test”. Effectuer un git add README.md puis un git commit -m "nouveau commit sur la branche principale". Tapez la commande :

$:~/courseGIT/tp3> git log --graph --oneline --all --decorate --topo-order
* f721aae (HEAD -> main) nouveau commit sur la branche principale
| * bee45b2 (test) fonction de test ajoutée
|/  
* 922b42b Adding CryptoMarche

Vous pouvez voir dans la sortie du log qu’une fourchette dans le code vient d’être produite. Visuellement, il y a maintenant une branche principale et une branche de test :

* (main)
| * (test) 
|/ 
* (main)

3.2. Fusionner la branche de test dans la branche principale

Athos et Porthos :

Travailler avec des branches serait inutile si à un certain moment on ne pouvait pas les fusionner. Imaginons que nous voulions ajouter la fonctionnalité test à notre branche principale. Pour ce faire, allons dans la branche principale :

$:~/courseGIT/tp3> git checkout main

puis nous utiliserons la commande git merge qui nous permet de fusionner des branches :

$:~/courseGIT/tp3> git merge test

pour visualiser la fusion, vous pouvez écrire la commande :

$:~/courseGIT/tp3> git log --graph --oneline --all --decorate --topo-order
*   454d00d (HEAD -> main) Merge branch 'test' into main
|\  
| * bee45b2 (test) fonction de test ajoutée
* | f721aae nouveau commit sur la branche principale
|/  
* 922b42b Adding CryptoMarche

Que se passe-t-il si nous tapons la commande ls ? :

$:~/courseGIT/tp3> ls
???

Exercices

Athos et Porthos faire les sections 3.1 et 3.2 séparément sans synchronisation avec le dépot github.

Ensuite, supprimez le fichier test.txt du dépôt, pour cela, écrivez la commande git rm test.txt puis git commit -m "test.txt supprimé".

Chacun de vous va créer une branche appelée AthosCoin et PorthosCoin respectivement. Dans cette branche, vous allez créer votre crypto-monnaie (suivez l’exemple d’AramisCoin ci-dessous). Une fois la devise créée, fusionnez la branche avec la branche principale. Assurez-vous ensuite que les modifications sont synchronisées dans le dépôt github.

public class AramisCoin extends Cryptomonnaie{
    public AramisCoin(){
        super("ARA", 1000);
    }
}

Haut de la page

Fin du TP 3