Exécuter les inspections IntelliJ depuis l'intégration continue

Exécution des inspections IntelliJ depuis l'intégration continue

IntelliJ IDEA propose des fonctionnalités pour améliorer notre code, directement dans l'IDE lors de la saisie, sous forme d'intentions. Ces intentions peuvent être utilisées en mode batch pour inspecter le code à la recherche de modèles dans toute la source, et même étendues à l'analyse en ligne de commande ou intégrées à l'intégration continue. Cet article couvre les fonctionnalités natives d'IntelliJ et leur extension avec des intentions personnalisées créées dans Sensei.

‍

Inspections IntelliJ

La fonctionnalité d'inspections d'IntelliJ gère l'affichage de nombreuses erreurs signalées dynamiquement dans l'IDE lors du codage, par exemple :

• la détection de classes abstraites pouvant être converties en interfaces,
• l'identification de champs de classe redondants pouvant être locaux,
• l'avertissement concernant l'utilisation de méthodes obsolètes,
• etc.

Ces inspections mettent en évidence le code correspondant dans l'IDE sous forme d'actions d'intention, souvent accompagnées d'une correction rapide (QuickFix).

La mise en évidence en temps réel dans l'IDE lorsqu'un code correspond à une inspection nous aide à améliorer notre codage de manière dynamique. Après avoir identifié le problème, l'utilisation des actions d'intention IntelliJ pour corriger rapidement le code permet de renforcer les bonnes pratiques.

Profil d'inspections

Les inspections peuvent être exécutées en mode batch depuis l'IDE, en ligne de commande ou dans un processus d'intégration continue.

La clé pour travailler avec les inspections IntelliJ en mode batch réside dans l'utilisation d'un profil d'inspections.

IntelliJ dispose de deux profils d'inspection par défaut : l'un stocké dans le projet et l'autre dans l'IDE.

De nouveaux profils d'inspection peuvent être créés pour configurer des plugins ou des cas d'utilisation spécifiques, par exemple :

• Exécuter uniquement l'analyse Checkstyle en temps réel
• Exécuter un ensemble spécifique de règles Sensei
• Exécuter les vérifications HTML
  

Les inspections d'un profil peuvent être activées ou désactivées depuis les préférences d'IntelliJ. La boîte de dialogue des préférences est également un moyen simple de découvrir l'éventail des inspections disponibles.

L'icône « outil » vous permet de dupliquer un profil et d'en créer un nouveau pour regrouper un ensemble spécifique de règles.

Exécution d'un profil d'inspection dans l'IDE

Les profils d'inspection peuvent être exécutés depuis l'IDE via le menu `Analyze \ Inspect Code...`.

La fonctionnalité d'analyse vous permet de définir la portée de l'inspection, par exemple sur l'ensemble du projet, en incluant ou en excluant les sources de test, ou sur un ensemble spécifique de fichiers.

Vous pouvez également gérer les profils d'inspection à partir d'ici pour créer ou configurer un profil particulier.

En cliquant sur [OK] dans la boîte de dialogue « Specify Inspection Scope », vous lancez l'exécution de toutes les inspections sélectionnées dans le profil sur la portée définie dans IntelliJ.

IntelliJ affichera les résultats de l'exécution des inspections dans l'onglet `Inspection Results`.

Le plugin Sensei de Secure Code Warrior vous permet de créer des recettes personnalisées de correspondance de code. Sensei s'intègre étroitement à IntelliJ pour rendre l'utilisation de ces recettes aussi naturelle que celle des actions d'intention d'IntelliJ. Cela signifie qu'elles sont chargées dans IntelliJ en tant qu'inspections et peuvent être regroupées, activées ou désactivées via les profils d'inspection. La création d'un profil d'inspection personnalisé, suivie de l'utilisation de la fonctionnalité d'analyse de code, est la méthode recommandée pour exécuter les recettes Sensei en masse sur un projet.

Exécuter un profil d'inspection depuis la ligne de commande

IntelliJ permet d'exécuter des inspections depuis la ligne de commande, comme documenté par JetBrains :

- https://www.jetbrains.com/help/idea/working-with-the-ide-features-from-command-line.html

J'utilise principalement macOS et je peux lancer une instance d'IntelliJ depuis la ligne de commande avec :

open -na "IntelliJ IDEA CE.app"

Pour faciliter l'exécution, j'ajoute ceci à un script de commande shell.

vi /usr/local/bin/idea

Le contenu du script provient de la documentation officielle fournie par IntelliJ.

#!/bin/sh
open -na "IntelliJ IDEA CE.app" --args "$@"

J'ai ensuite rendu ce fichier exécutable pour simplifier le processus d'inspection en ligne de commande.

chmod 755 /usr/local/bin/idea

La documentation officielle d'IntelliJ décrit la forme générale de la commande d'inspection comme suit :

idea inspect <project> <inspection-profile> <output></output></inspection-profile></project>
[<options>]</options>

En pratique, je spécifie les chemins complets et je n'ai besoin d'aucune option :

idea inspect /Users/user/GitHub/sensei-blog-examples /Users/user/GitHub/sensei-blog-examples/.idea/inspectionProfiles/senseiprofile.xml /Users/user/GitHub/sensei-blog-examples/scan-results

Cette commande exécute toutes les inspections ajoutées au profil `senseiprofile` et génère un rapport dans le dossier `scan-results`.

Visualisation des résultats d'inspection

Nous pouvons générer ces rapports dans le cadre d'une intégration continue, comme nous le verrons plus loin.

Nous pouvons également les consulter directement dans IntelliJ via la fonctionnalité `Analyse \ View Offline Inspection Results…`.

Cela chargera les résultats dans l'onglet `Inspection Results`.

La procédure est officiellement documentée sur le site de JetBrains :

- https://www.jetbrains.com/help/idea/command-line-code-inspector.html#inspection-results

Cette méthode peut être utilisée lors d'une revue de code si l'exécution en ligne de commande a été intégrée à un processus d'intégration continue et que les relecteurs souhaitent examiner le contexte source complet des résultats d'inspection.

Profils d'inspection en intégration continue

Lors de l'ajout de l'inspection en ligne de commande à l'intégration continue, l'idéal est de générer un rapport automatiquement ; plusieurs options s'offrent à nous.

TeamCity propose une prise en charge native des profils d'inspection pour l'intégration continue.

- https://www.jetbrains.com/help/teamcity/inspections.html

Le plugin Jenkins Warnings NG prend en charge la sortie en ligne de commande des inspections IntelliJ comme format de rapport.

- https://github.com/jenkinsci/warnings-ng-plugin

- https://github.com/jenkinsci/warnings-ng-plugin/blob/master/SUPPORTED-FORMATS.md

Des projets communautaires comme `idea CLI Inspector` existent pour permettre l'utilisation des profils d'inspection avec d'autres outils d'intégration continue.

- https://github.com/bentolor/idea-cli-inspector

L'avenir des profils d'inspection dans les processus d'intégration continue s'annonce encore plus prometteur avec l'introduction du projet JetBrains Qodana. Qodana est une version « headless » (sans interface graphique) d'IntelliJ, proposant des actions GitHub et des images Docker officielles.

- https://github.com/JetBrains/Qodana

Qodana est actuellement en version bêta, mais l'équipe Sensei le suit de près afin d'en faire une plateforme officiellement prise en charge pour exécuter les règles Sensei dans le cadre de l'intégration continue.

Résumé

Les actions d'intention nous permettent de renforcer les modèles de codage et de les corriger rapidement dans l'IDE lorsque nous commettons des erreurs lors du développement.

Les profils d'inspection permettent de les regrouper pour les exécuter par lots via l'action Analyser et inspecter le code. Cela s'avère utile si nous identifions un modèle et souhaitons vérifier s'il n'a pas été oublié ailleurs dans notre code.

Les profils d'inspection peuvent être exécutés depuis la ligne de commande et intégrés aux processus d'intégration continue, favorisant un modèle de « confiance, mais vérification » pour détecter tout écart accidentel.

Tout ce qui précède est une fonctionnalité intégrée d'IntelliJ, et JetBrains améliore ses processus d'intégration continue avec l'introduction de Qodana.

Les recettes Sensei sont chargées dans IntelliJ pour agir comme des actions d'intention natives et être regroupées dans des profils d'inspection, permettant une vérification par lots et une intégration continue via la ligne de commande JetBrains.

---

Vous pouvez installer Sensei depuis IntelliJ via « Préférences > Plugins » (Mac) ou « Paramètres > Plugins » (Windows) en recherchant simplement « sensei secure code ».

Si vous souhaitez tester l'exécution d'un projet IntelliJ en ligne de commande, le projet utilisé dans cet article est disponible dans le dépôt `sensei-blog-examples` du compte GitHub de Secure Code Warrior. À vous de jouer : créez un profil pour exécuter uniquement les règles Sensei. Essayez !

https://github.com/securecodewarrior/sensei-blog-examples

En savoir plus sur Sensei