Implement comprehensive dependency injection with Guice, integrate service layer architecture, add complete testing infrastructure, and enhance CI/CD pipeline for improved maintainability and Folia extensibility (#151)

Author: TheMeinerLP

.github/workflows/build-pr.yml

@@ -22,4 +22,23 @@ jobs:
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4
       - name: Build on ${{ matrix.os }}
-        run: ./gradlew clean build test
+        run: ./gradlew clean build test
+      - name: Publish Test Results
+        uses: EnricoMi/publish-unit-test-result-action@v2
+        if: always() && matrix.os == 'ubuntu-latest'
+        with:
+          files: "**/build/test-results/test/TEST-*.xml"
+          check_name: "Test Results"
+          comment_title: "Unit Test Results"
+      - name: Upload Test Report
+        uses: actions/upload-artifact@v4
+        if: always() && matrix.os == 'ubuntu-latest'
+        with:
+          name: test-report
+          path: build/reports/tests/test/
+      - name: Upload Coverage Reports
+        uses: actions/upload-artifact@v4
+        if: always() && matrix.os == 'ubuntu-latest'
+        with:
+          name: coverage-report
+          path: build/reports/jacoco/test/

build.gradle.kts

@@ -9,6 +9,7 @@ plugins {
     alias(libs.plugins.paper.yml)
     alias(libs.plugins.hangar)
     alias(libs.plugins.modrinth)
+    jacoco
 }
 
 if (!File("$rootDir/.git").exists()) {
@@ -59,13 +60,23 @@ dependencies {
     implementation(libs.cloud.command.annotations)
     implementation(libs.semver)
     implementation(libs.adventure.text.feature.pagination)
+    implementation(libs.guice)
+    implementation(libs.jakarta.inject)
     annotationProcessor(libs.cloud.command.annotations)
 
     implementation(project(":internal-api"))
     implementation(project(":WorldGuardv6Support"))
     implementation(project(":WorldGuardv7Support"))
     implementation(project(":PlotSquaredv6Support"))
     implementation(project(":PlotSquaredv7Support"))
+
+    // Testing dependencies
+    testImplementation(libs.junit.jupiter)
+    testImplementation(libs.mockito.core)
+    testImplementation(libs.mockito.junit.jupiter)
+    testImplementation(libs.mockbukkit)
+    testImplementation(libs.assertj.core)
+    testRuntimeOnly(libs.junit.platform.launcher)
 }
 
 tasks {
@@ -75,6 +86,24 @@ tasks {
     named("build") {
         dependsOn(shadowJar)
     }
+    test {
+        useJUnitPlatform()
+        testLogging {
+            events("passed", "skipped", "failed")
+            exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
+            showStandardStreams = false
+        }
+        maxParallelForks = 1
+        
+        // Generate test reports
+        reports {
+            junitXml.required.set(true)
+            html.required.set(true)
+        }
+        
+        // Test result publication
+        finalizedBy(jacocoTestReport)
+    }
     supportedMinecraftVersions.forEach { serverVersion ->
         register<RunServer>("run-$serverVersion") {
             minecraftVersion(serverVersion)
@@ -91,6 +120,14 @@ tasks {
     this.modrinth {
         dependsOn(shadowJar)
     }
+    
+    jacocoTestReport {
+        dependsOn(test)
+        reports {
+            xml.required.set(true)
+            html.required.set(true)
+        }
+    }
 }
 
 

docs/DEPENDENCY_INJECTION.md

@@ -0,0 +1,105 @@
+# Dependency Injection Implementation
+
+This document describes the dependency injection (DI) implementation using Google Guice to improve the maintainability and extensibility of AntiRedstoneClock-Remastered.
+
+## Overview
+
+The plugin has been refactored to use dependency injection patterns, making it more modular and easier to test. The implementation uses Google Guice as the DI framework.
+
+## Module Structure
+
+### ServiceModule
+Manages core plugin services:
+- `RedstoneClockService` - Core redstone clock detection logic
+- `UpdateService` - Plugin update checking and notifications
+- `CheckTPS` - TPS monitoring functionality
+- `TranslationService` - Internationalization support (provider method selects modern/legacy based on server version)
+
+### ExternalSupportModule
+Handles optional external plugin integrations:
+- `WorldGuardSupport` - Integration with WorldGuard plugin (provider method selects v6/v7 based on version)
+- `PlotsquaredSupport` - Integration with PlotSquared plugin (provider method selects v6/v7 based on version)
+
+### CommandModule
+Manages command classes:
+- `ReloadCommand`
+- `DisplayActiveClocksCommand`
+- `FeatureCommand`
+
+### ListenerModule
+Manages event listeners:
+- `PlayerListener`
+- `ObserverListener`
+- Additional listeners can be added as they get refactored
+
+## Benefits
+
+### 1. Improved Maintainability
+- Dependencies are explicitly declared through constructor injection
+- No more manual service creation scattered throughout the main class
+- Clear separation of concerns between different modules
+
+### 2. Enhanced Testability
+- Services can be easily mocked for unit testing
+- Dependencies are injected rather than hard-coded
+- Easier to create isolated test scenarios
+
+### 3. Better Extensibility for Folia
+- Service layer is now modular and can be easily extended
+- Platform-specific implementations can be swapped in via configuration
+- Clear interface boundaries make it easier to add platform-specific optimizations
+
+### 4. Reduced Coupling
+- Classes depend on interfaces rather than concrete implementations
+- Easier to change implementations without affecting consumers
+- Better adherence to SOLID principles
+
+## Usage Examples
+
+### Injecting Dependencies
+```java
+@Singleton
+public class SomeService {
+    private final RedstoneClockService clockService;
+    private final CheckTPS tpsChecker;
+    
+    @Inject
+    public SomeService(RedstoneClockService clockService, CheckTPS tpsChecker) {
+        this.clockService = clockService;
+        this.tpsChecker = tpsChecker;
+    }
+}
+```
+
+### Adding New Services
+To add a new service:
+1. Create the service class with `@Inject` constructor
+2. Add `@Singleton` if it should be a singleton
+3. Bind it in the appropriate module's `configure()` method
+4. Inject it where needed
+
+### Creating Platform-Specific Implementations
+```java
+@Provides
+@Singleton
+public SomeService provideSomeService(AntiRedstoneClockRemastered plugin) {
+    if (plugin.getServer().getName().equals("Folia")) {
+        return new FoliaSomeService(plugin);
+    } else {
+        return new DefaultSomeService(plugin);
+    }
+}
+```
+
+## Migration Notes
+
+- Legacy listeners that haven't been refactored yet still use manual instantiation
+- External support (WorldGuard/PlotSquared) now uses provider methods for version detection
+- The main plugin class is significantly simplified with most manual setup removed
+
+## Future Improvements
+
+1. Refactor remaining listeners to use DI
+2. Add interface abstractions for better testability
+3. Consider platform-specific modules for Folia support
+4. Add configuration-based service selection