Test des constantes dans Go

Dans Go, les constantes sont un outil précieux pour garantir la cohérence et l'exactitude du code. Cependant, lorsqu’il s’agit de tests unitaires, l’utilisation de constantes peut créer des défis. Cet article explique comment redéfinir les constantes spécifiquement à des fins de test dans Go.

Le défi avec les constantes

Les constantes dans Go sont des valeurs immuables qui ne peuvent pas être modifiées pendant l'exécution du programme. Cette immuabilité garantit l'intégrité de l'état du programme et empêche les modifications accidentelles. Cependant, pendant les tests, il peut être nécessaire de modifier temporairement les constantes pour tester des scénarios spécifiques.

Une approche conviviale pour les tests

Prenons l'exemple suivant :

package main

const baseUrl = "http://google.com"

// in main_test.go
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  ...
}))
const baseUrl = ts.URL // Error: const baseUrl already defined

Dans cet exemple, nous souhaitons utiliser un serveur de test au lieu d'appeler l'API distante pour les tests. Pour ce faire, nous devons redéfinir baseUrl avec l'URL du serveur de test. Cependant, Go génère une erreur car la constante baseUrl est déjà définie.

Solution : Refactoriser pour la testabilité

Pour faciliter les tests, nous pouvons légèrement refactoriser le code en introduisant une fonction supplémentaire :

const baseUrl_ = "http://google.com"

func MyFunc() string {
    // Call other function passing the const value
    return myFuncImpl(baseUrl_)
}

func myFuncImpl(baseUrl string) string {
    // use baseUrl
    // Same implementation that was in your original MyFunc() function
}

Dans ce code refactorisé, la fonction MyFunc d'origine délègue son implémentation à myFuncImpl, qui prend un paramètre baseUrl. Cela nous permet d'appeler myFuncImpl directement à partir d'une fonction de test et de transmettre n'importe quelle URL de base souhaitée.

Garder la sécurité du code de production

La fonction MyFunc d'origine reste sûre et non affectée par la refactorisation. Il transmet toujours la constante baseUrl_ à myFuncImpl, garantissant que le code de production n'a pas de comportement inattendu en raison de constantes modifiées.

Conclusion

Cette technique permet aux développeurs de redéfinir les constantes à des fins de test tout en préservant l'intégrité et la sécurité du code de production. En introduisant une fonction supplémentaire qui fournit les mêmes fonctionnalités que l'original, les tests peuvent modifier les constantes sans affecter le comportement réel du code.