Résoudre le Défi des Tests Unitaires Gradle avec `gradle.properties`

Содержание

Проблема: Изолировать юнит‑тесты плагина Gradle
- Архитектура проблемы
- Соблазн ложной хорошей идеи
Решение: моделирование свойства с помощью `ExtraPropertiesExtension
Преимущества этого подхода
Хорошие практики и советы
- Создать вспомогательный метод
- Валидация свойств
Заключение

Проблема: Изолировать юнит‑тесты плагина Gradle

При написании юнит-тестов для Gradle-плагина распространённой задачей является управление зависимостями от конфигурации проекта, например, свойствами, определёнными в файле`gradle.properties`. В нашем случае, плагин`jbake.ghpages`должен был прочитать свойство`site_config_path`чтоб работать правильно. Юнит-тест для задачи`initialize`должен был проверить поведение плагина при наличии этого свойства.

Фундаментальная проблема заключается в том, что модульные тесты, по своей сути, должны быть изолированы. Использование`ProjectBuilder`Gradle создаёт экземпляр`Project`в памяти, полностью отключена от реального проекта в файловой системе. Поэтому этот тестовый экземпляр не читает файл автоматически.gradle.properties`и поэтому не знает о свойстве`site_config_path.

Архитектура проблемы

Следующая схема иллюстрирует разрыв между тестовой средой и файловой системой :

@startuml
!define RECTANGLE class

package "Environnement de Production" {
  RECTANGLE ProjectReal {
    + build.gradle.kts
    + gradle.properties
    + src/
  }

  RECTANGLE GradleProperties {
    site_config_path=src/jbake/settings/site.yml
  }

  RECTANGLE JbakePlugin {
    - readProperty(name: String)
    + initialize()
  }

  ProjectReal --> GradleProperties : lit au démarrage
  JbakePlugin --> GradleProperties : accède via project.properties
}

package "Environnement de Test" {
  RECTANGLE ProjectTest {
    + Créé par ProjectBuilder
    + En mémoire uniquement
    + Pas de gradle.properties
  }

  RECTANGLE JbakePluginTest {
    + testInitialize()
  }

  ProjectTest -[#red]x GradleProperties : ❌ Pas d'accès
  JbakePluginTest --> ProjectTest : utilise
}

note right of ProjectTest : Isolation = Pas d'accès\nau système de fichiers
@enduml

Соблазн ложной хорошей идеи

Первый подход может заключаться в создании файла.`gradle.properties`фиктивный в ресурсах теста.

// src/test/resources/gradle.properties
site_config_path=src/jbake/settings/site.yml

Однако этот метод обречён на провал, потому что`ProjectBuilder`не предназначен для сканирования файловой системы в поиске файлов конфигурации. Тест оставался бы изолированным и игнорировал этот файл.

Решение: моделирование свойства с помощью `ExtraPropertiesExtension

Элегантное решение этой проблемы заключается не в чтении файла, а в симуляции наличия свойства непосредственно в объекте`Project`де test. Gradle предоставляет мощный механизм для этого: дополнительные свойства (Extra Properties).

Шаг 1: Понять ExtraPropertiesExtension

`ExtraPropertiesExtension`является контейнером «ключ‑значение», привязанным к каждому объекту модели Gradle. Он позволяет динамически добавлять свойства к проекту, задаче или любому другому расширению Gradle.

@startuml
!define RECTANGLE class

RECTANGLE Project {
  + name: String
  + version: String
  + extensions: ExtensionContainer
  + properties: Map<String, ?>
}

RECTANGLE ExtensionContainer {
  + getByType(Class<T>): T
  + add(String, Object): void
}

RECTANGLE ExtraPropertiesExtension {
  + set(String, Object): void
  + get(String): Object
  + has(String): boolean
  + getProperties(): Map<String, Object>
}

Project --> ExtensionContainer : contient
ExtensionContainer --> ExtraPropertiesExtension : gère
ExtraPropertiesExtension --> Project : synchronise avec\nproject.properties

note right of ExtraPropertiesExtension : Point d'entrée pour\ninjecter des propriétés
@enduml

Этап 2: настройка теста - подготовка

Начнём с создания базовой структуры нашего юнит‑теста :

JbakeGhPagesPluginTest.kt - Structure de base

class JbakeGhPagesPluginTest {

    @TempDir
    lateinit var testProjectDir: File

    @Test
    fun `check initialize and config yaml file if not existing`() {
        // Étape 1 : Créer un projet de test isolé
        val project = ProjectBuilder.builder()
            .withProjectDir(testProjectDir)
            .build()

        // Suite des étapes...
    }
}

Шаг 3: Инъекция свойства

Вот подробный процесс внедрения свойства в тестовый проект:

JbakeGhPagesPluginTest.kt - Injection complète

@Test
fun `check initialize and config yaml file if not existing`() {
    // Étape 1 : Créer un projet de test isolé en mémoire
    val project = ProjectBuilder.builder()
        .withProjectDir(testProjectDir)
        .build()

    // Étape 2 : Récupérer le gestionnaire de propriétés supplémentaires
    val extra = project.extensions.getByType(ExtraPropertiesExtension::class.java)

    // Étape 3 : Définir la propriété requise pour ce test
    extra.set("site_config_path", "src/jbake/settings/site.yml")

    // Étape 4 : Vérifier que la propriété est bien injectée
    assertTrue(project.hasProperty("site_config_path"))

    // Étape 5 : Appliquer le plugin qui pourra maintenant accéder à la propriété
    project.plugins.apply("jbake.ghpages")

    // Étape 6 : Exécuter la tâche et vérifier son comportement
    val task: Task = project.tasks.findByName("initialize")
        .apply(::assertNotNull)!!

    // Étape 7 : Exécuter les actions de la tâche
    task.actions.forEach { it.execute(task) }

    // Étape 8 : Assertions finales
    assertEquals(
        "src/jbake/settings/site.yml",
        project.properties["site_config_path"],
        "La propriété devrait être accessible dans le projet"
    )
}

Этап 4: Схема потока решения

@startuml
start

:Créer ProjectBuilder;
:Obtenir ExtraPropertiesExtension;
:Injecter la propriété\nvia extra.set();

partition "Vérifications" {
  :Vérifier project.hasProperty();
  :Appliquer le plugin;
  :Récupérer la tâche;
}

partition "Exécution" {
  :Exécuter les actions\nde la tâche;
  :Le plugin lit\nproject.properties;
}

partition "Assertions" {
  :Vérifier la propriété\nest accessible;
  :Valider le comportement\nattendues;
}

stop
@enduml

Шаг 5: сравнение До/После

@startuml
!define RECTANGLE class

package "AVANT - Problématique" {
  RECTANGLE TestProject1 {
    + ProjectBuilder.build()
    + Pas de propriétés
  }

  RECTANGLE Plugin1 {
    + initialize()
    + ❌ project.properties["site_config_path"] = null
  }

  TestProject1 --> Plugin1 : échec

  note right of Plugin1 : Test échoue car\nla propriété n'existe pas
}

package "APRÈS - Solution" {
  RECTANGLE TestProject2 {
    + ProjectBuilder.build()
    + ExtraPropertiesExtension
  }

  RECTANGLE ExtraProps {
    + set("site_config_path", "...")
  }

  RECTANGLE Plugin2 {
    + initialize()
    + ✅ project.properties["site_config_path"] = "src/jbake/settings/site.yml"
  }

  TestProject2 --> ExtraProps : configure
  ExtraProps --> Plugin2 : propriété disponible

  note right of Plugin2 : Test réussit car\nla propriété est simulée
}
@enduml

Шаг 6: управление множественными тестовыми случаями

Чтобы протестировать разные сценарии, давайте создадим несколько тестов с различными конфигурациями :

Tests multiples avec configurations différentes

class JbakeGhPagesPluginTest {

    @TempDir
    lateinit var testProjectDir: File

    private fun createProjectWithProperty(propertyValue: String?): Project {
        val project = ProjectBuilder.builder()
            .withProjectDir(testProjectDir)
            .build()

        // Injection conditionnelle de la propriété
        propertyValue?.let { value ->
            val extra = project.extensions.getByType(ExtraPropertiesExtension::class.java)
            extra.set("site_config_path", value)
        }

        return project
    }

    @Test
    fun `should work with valid property`() {
        val project = createProjectWithProperty("src/jbake/settings/site.yml")
        project.plugins.apply("jbake.ghpages")

        val task = project.tasks.findByName("initialize")!!
        task.actions.forEach { it.execute(task) }

        // Assertions pour le cas normal
        assertEquals("src/jbake/settings/site.yml", project.properties["site_config_path"])
    }

    @Test
    fun `should handle missing property gracefully`() {
        val project = createProjectWithProperty(null) // Pas de propriété
        project.plugins.apply("jbake.ghpages")

        val task = project.tasks.findByName("initialize")!!

        // Le plugin devrait gérer l'absence de propriété
        assertDoesNotThrow {
            task.actions.forEach { it.execute(task) }
        }
    }

    @Test
    fun `should handle invalid property path`() {
        val project = createProjectWithProperty("invalid/path/to/config.yml")
        project.plugins.apply("jbake.ghpages")

        val task = project.tasks.findByName("initialize")!!

        // Test du comportement avec un chemin invalide
        assertThrows<FileNotFoundException> {
            task.actions.forEach { it.execute(task) }
        }
    }
}

Финальная архитектура решения

@startuml
!define RECTANGLE class

package "Test Environment" {
  RECTANGLE TestClass {
    + createProjectWithProperty()
    + testValidProperty()
    + testMissingProperty()
    + testInvalidProperty()
  }

  RECTANGLE ProjectBuilder {
    + builder()
    + withProjectDir()
    + build()
  }

  RECTANGLE TestProject {
    + extensions
    + properties
    + plugins
    + tasks
  }

  RECTANGLE ExtraPropertiesExtension {
    + set(key, value)
    + get(key)
    + has(key)
  }

  RECTANGLE JbakePlugin {
    + apply(project)
    + createInitializeTask()
    + readSiteConfigPath()
  }
}

TestClass --> ProjectBuilder : utilise
ProjectBuilder --> TestProject : crée
TestProject --> ExtraPropertiesExtension : contient
TestClass --> ExtraPropertiesExtension : configure
ExtraPropertiesExtension --> TestProject : synchronise properties
TestProject --> JbakePlugin : applique
JbakePlugin --> TestProject : lit properties

note right of ExtraPropertiesExtension : Point de contrôle\npour l'injection
note bottom of TestProject : Environnement\ncontrôlé et isolé
@enduml

Преимущества этого подхода

полная изоляция: Тест не зависит от никаких внешних файлов. Он автономен и может выполняться надежно в любой среде (локальной, CI/CD и т.д.).
Ясность и намерение: Тест явно объявляет предварительные условия для его выполнения. Кто читает тест, сразу видит, что плагин требует свойства.`site_config_path`чтобы работать.
поддерживаемостьЕсли имя свойства меняется, достаточно обновить его в одном месте теста, без необходимости манипулировать файлами конфигурации теста.
ГибкостьСтает тривиально тестировать разные сценарии, просто меняя значение внедренного свойства в каждом тесте (допустимое значение, недопустимое, отсутствующее и т.д.).
производительностьНет чтения файлов, всё происходит в памяти, что делает тесты быстрее.
ВоспроизводимостьТесты являются детерминированными, так как они не зависят от состояния файловой системы.

Хорошие практики и советы

Создать вспомогательный метод

Méthode utilitaire pour la réutilisation

class GradleTestUtils {
    companion object {
        fun createProjectWithProperties(
            projectDir: File,
            properties: Map<String, String>
        ): Project {
            val project = ProjectBuilder.builder()
                .withProjectDir(projectDir)
                .build()

            val extra = project.extensions.getByType(ExtraPropertiesExtension::class.java)
            properties.forEach { (key, value) ->
                extra.set(key, value)
            }

            return project
        }
    }
}

Валидация свойств

Validation robuste

@Test
fun `should validate property injection`() {
    val project = createProjectWithProperty("test-value")

    // Vérifications multiples
    assertTrue(project.hasProperty("site_config_path"))
    assertEquals("test-value", project.property("site_config_path"))
    assertNotNull(project.properties["site_config_path"])

    // Vérification que la propriété est accessible par le plugin
    project.plugins.apply("jbake.ghpages")
    // ... reste du test
}

Заключение

Вместо того чтобы бороться, заставляя среду единичного тестирования читать файлы конфигурации, наилучшей практикой является имитация необходимого состояния. Использование`ExtraPropertiesExtension`Для программного задания свойств Gradle — это самый чистый и надежный способ выполнения эффективных и надежных юнит-тестов плагинов.

Этот метод превращает проблему внешней зависимости в простую инъекцию зависимости, находясь в самом сердце философии разработки через тестирование (TDD). Он обеспечивает полный контроль над тестовой средой, сохраняя при этом необходимую изоляцию для качественных юнит-тестов.

Диаграммы и примеры, представленные в этой статье, показывают, как этот подход может быть реализован постепенно и методично, позволяя создать надежный и поддерживаемый набор тестов для ваших плагинов Gradle.