Fess Fess 15.3
Support

Menu

Général

Introduction

Documentation

Tutoriel

Développement

Autres

Archives

Support

Compilation et tests

Cette page explique les méthodes de compilation, de test, et de création de packages de distribution de Fess.

Aperçu du système de compilation

Fess utilise Maven comme outil de compilation. Maven automatise la gestion des dépendances, la compilation, les tests et le packaging.

pom.xml

C’est le fichier de configuration de Maven. Il est placé dans le répertoire racine du projet.

Principaux contenus de configuration :

  • Informations du projet (groupId, artifactId, version)

  • Bibliothèques dépendantes

  • Plugins de compilation

  • Profils

Commandes de compilation de base

Compilation propre

Supprimez les artefacts de compilation, puis recompilez :

mvn clean compile

Création de package

Créez un fichier JAR exécutable :

mvn package

Les artefacts sont générés dans le répertoire target/ :

target/
├── fess-15.3.x.jar
└── fess-15.3.x/

Compilation complète

Exécutez clean, compilation, tests et packaging :

mvn clean package

Téléchargement des dépendances

Téléchargez les bibliothèques dépendantes :

mvn dependency:resolve

Téléchargement des plugins OpenSearch

Téléchargez OpenSearch et les plugins requis :

mvn antrun:run

Note

Cette commande est exécutée lors de la configuration de l’environnement de développement ou lors de la mise à jour des plugins.

Tests

Fess implémente les tests en utilisant JUnit.

Exécution des tests unitaires

Exécuter tous les tests unitaires

mvn test

Exécuter une classe de test spécifique

mvn test -Dtest=SearchServiceTest

Exécuter une méthode de test spécifique

mvn test -Dtest=SearchServiceTest#testSearch

Exécuter plusieurs classes de tests

mvn test -Dtest=SearchServiceTest,CrawlerTest

Ignorer les tests

Pour compiler en ignorant les tests :

mvn package -DskipTests

Avertissement

Pendant le développement, n’ignorez pas les tests et exécutez-les toujours. Avant de créer une PR, vérifiez que tous les tests passent.

Exécution des tests d’intégration

Exécutez tous les tests, y compris les tests d’intégration :

mvn verify

Rédaction de tests

Création de tests unitaires

Placement des classes de tests

Placez les classes de tests sous src/test/java/. La structure des packages doit être la même que le code principal.

src/
├── main/java/org/codelibs/fess/app/service/SearchService.java
└── test/java/org/codelibs/fess/app/service/SearchServiceTest.java

Structure de base de la classe de test

package org.codelibs.fess.app.service;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class SearchServiceTest {

    @Test
    public void testSearch() {
        // Given: Conditions préalables du test
        SearchService service = new SearchService();
        String query = "test";

        // When: Exécution du sujet du test
        SearchResponse response = service.search(query);

        // Then: Vérification des résultats
        assertNotNull(response);
        assertTrue(response.getResultCount() > 0);
    }
}

Cycle de vie des tests

import org.junit.jupiter.api.*;

public class MyServiceTest {

    @BeforeAll
    static void setUpClass() {
        // Exécuté une fois avant tous les tests
    }

    @BeforeEach
    void setUp() {
        // Exécuté avant chaque test
    }

    @Test
    void testSomething() {
        // Test
    }

    @AfterEach
    void tearDown() {
        // Exécuté après chaque test
    }

    @AfterAll
    static void tearDownClass() {
        // Exécuté une fois après tous les tests
    }
}

Assertions

Utilisez les assertions de JUnit 5 :

import static org.junit.jupiter.api.Assertions.*;

// Égalité
assertEquals(expected, actual);
assertNotEquals(unexpected, actual);

// Vérification null
assertNull(obj);
assertNotNull(obj);

// Valeur booléenne
assertTrue(condition);
assertFalse(condition);

// Exceptions
assertThrows(IllegalArgumentException.class, () -> {
    service.doSomething();
});

// Collections
assertIterableEquals(expectedList, actualList);

Utilisation de mocks

Créez des mocks en utilisant Mockito :

import static org.mockito.Mockito.*;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.junit.jupiter.api.extension.ExtendWith;

@ExtendWith(MockitoExtension.class)
public class SearchServiceTest {

    @Mock
    private SearchEngineClient searchEngineClient;

    @Test
    public void testSearch() {
        // Configuration du mock
        when(searchEngineClient.search(anyString()))
            .thenReturn(new SearchResponse());

        // Exécution du test
        SearchService service = new SearchService();
        service.setSearchEngineClient(searchEngineClient);
        SearchResponse response = service.search("test");

        // Vérification
        assertNotNull(response);
        verify(searchEngineClient, times(1)).search("test");
    }
}

Couverture des tests

Mesurez la couverture des tests avec JaCoCo :

mvn clean test jacoco:report

Le rapport est généré dans target/site/jacoco/index.html.

Vérification de la qualité du code

Checkstyle

Vérifiez le style de codage :

mvn checkstyle:check

Le fichier de configuration se trouve dans checkstyle.xml.

SpotBugs

Détectez les bugs potentiels :

mvn spotbugs:check

PMD

Détectez les problèmes de qualité du code :

mvn pmd:check

Exécuter toutes les vérifications

mvn clean verify checkstyle:check spotbugs:check pmd:check

Création de packages de distribution

Création de packages de release

Créez des packages pour la distribution :

mvn clean package

Artefacts générés :

target/releases/
├── fess-15.3.x.tar.gz      # Pour Linux/macOS
├── fess-15.3.x.zip         # Pour Windows
├── fess-15.3.x.rpm         # Package RPM
└── fess-15.3.x.deb         # Package DEB

Création d’images Docker

Créez une image Docker :

mvn package docker:build

Image générée :

docker images | grep fess

Profils

Vous pouvez appliquer différentes configurations pour chaque environnement en utilisant les profils Maven.

Profil de développement

Compilez avec les paramètres de développement :

mvn package -Pdev

Profil de production

Compilez avec les paramètres de production :

mvn package -Pprod

Compilation rapide

Compilez rapidement en ignorant les tests et les vérifications :

mvn package -Pfast

Avertissement

La compilation rapide est destinée à la vérification pendant le développement. Avant de créer une PR, exécutez toujours une compilation complète.

CI/CD

Fess utilise GitHub Actions pour exécuter CI/CD.

GitHub Actions

Les fichiers de configuration se trouvent dans le répertoire .github/workflows/.

Vérifications automatiquement exécutées :

  • Compilation

  • Tests unitaires

  • Tests d’intégration

  • Vérification du style de code

  • Vérification de la qualité du code

Vérification CI en local

Avant de créer une PR, vous pouvez exécuter les mêmes vérifications que CI en local :

mvn clean verify checkstyle:check

Dépannage

Erreurs de compilation

Erreur : Échec du téléchargement des dépendances

# Nettoyer le dépôt local Maven
rm -rf ~/.m2/repository
mvn clean compile

Erreur : Mémoire insuffisante

# Augmenter la mémoire Maven
export MAVEN_OPTS="-Xmx2g -XX:MaxPermSize=512m"
mvn clean package

Erreur : Version Java obsolète

Utilisez Java 21 ou supérieur :

java -version

Erreurs de test

Les tests expirent

Prolongez le délai d’expiration des tests :

mvn test -Dmaven.test.timeout=600

OpenSearch ne démarre pas

Vérifiez les ports et changez-les s’ils sont utilisés :

lsof -i :9201

Problèmes de dépendances

Conflits de dépendances

Vérifiez l’arbre des dépendances :

mvn dependency:tree

Exclure une dépendance spécifique :

<dependency>
    <groupId>org.example</groupId>
    <artifactId>example-lib</artifactId>
    <version>1.0</version>
    <exclusions>
        <exclusion>
            <groupId>conflicting-lib</groupId>
            <artifactId>conflicting-lib</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Meilleures pratiques de compilation

Compilation propre régulière

Exécutez régulièrement une compilation propre pour éviter les problèmes de cache de compilation :

mvn clean package

Exécution des tests

Exécutez toujours les tests avant de commiter :

mvn test

Vérification de la qualité du code

Vérifiez la qualité du code avant de créer une PR :

mvn checkstyle:check spotbugs:check

Mise à jour des dépendances

Mettez à jour régulièrement les dépendances :

mvn versions:display-dependency-updates

Utilisation du cache de compilation

Utilisez le cache Maven pour réduire le temps de compilation :

# Ignorer si déjà compilé
mvn compile

Référence des commandes Maven

Commandes couramment utilisées

# Clean
mvn clean

# Compilation
mvn compile

# Tests
mvn test

# Package
mvn package

# Installation (enregistrement dans le dépôt local)
mvn install

# Vérification (y compris les tests d'intégration)
mvn verify

# Résolution des dépendances
mvn dependency:resolve

# Affichage de l'arbre des dépendances
mvn dependency:tree

# Affichage des informations du projet
mvn help:effective-pom

Étapes suivantes

Après avoir compris les méthodes de compilation et de test, consultez la documentation suivante :

Ressources de référence