Modernize plugin template build system, fix CI workflows, and enable local JUnit testing

errorcodeQQ · errorcodeQQ · commit 3713b1cc529f · 2026-06-20T20:55:22.000+05:30
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -19,36 +19,39 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@master
+        uses: actions/checkout@v6
         with:
           path: "src"
 
       - name: Checkout builds
-        uses: actions/checkout@master
+        uses: actions/checkout@v6
         with:
           ref: "builds"
           path: "builds"
       
       - name: Clean old builds
         run: |
-          rm -f $GITHUB_WORKSPACE/builds/*.cs3
-          rm -f $GITHUB_WORKSPACE/builds/*.jar
+          rm $GITHUB_WORKSPACE/builds/*.cs3 || true
+          rm $GITHUB_WORKSPACE/builds/*.jar || true
 
-      - name: Setup JDK 17
-        uses: actions/setup-java@v1
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
         with:
-          java-version: 17
+          distribution: temurin
+          java-version: '17'
 
-      - name: Setup Android SDK
-        uses: android-actions/setup-android@v2
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v5
+        with:
+          cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
+          cache-read-only: false
 
       - name: Build Plugins
         run: |
           cd $GITHUB_WORKSPACE/src
           # Dynamically enable all plugins by clearing disabled list in settings.gradle.kts
-          python3 -c "import re; content = open('settings.gradle.kts').read(); open('settings.gradle.kts', 'w').write(re.sub(r'val disabled = listOf<String>\([^)]*\)', 'val disabled = listOf<String>()', content))"
           chmod +x gradlew
-          ./gradlew make makePluginsJson
+          ./gradlew makePluginsJson
           cp **/build/*.cs3 $GITHUB_WORKSPACE/builds
           cp **/build/*.jar $GITHUB_WORKSPACE/builds || true
           cp build/plugins.json $GITHUB_WORKSPACE/builds
diff --git a/.gitignore b/.gitignore
@@ -35,3 +35,6 @@ cs3_plugin_development_guide.md
 cs3 plugin development guide.md
 cs3_plugin_development_guide_recovered.md
 cs3_plugin_development_guide_recovered_full.md
+
+jdk17*
+
diff --git a/ExampleProvider/build.gradle.kts b/ExampleProvider/build.gradle.kts
@@ -1,17 +1,27 @@
-dependencies {
-    // Add provider-specific dependencies here if needed.
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4")
-}
-
+// Use an integer for version numbers
 version = 1
 
 cloudstream {
     description = "Example Provider Template"
     authors = listOf("author")
+    language = "en"
+
+    /**
+     * Status int:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     */
     status = 3
+
+    // List of video source types. See:
+    // https://recloudstream.github.io/cloudstream/html/app/com.lagradost.cloudstream3/-tv-type/index.html
     tvTypes = listOf("Movie", "TvSeries", "Anime", "AnimeMovie")
+
+    // iconUrl = "https://raw.githubusercontent.com/<user>/<repo>/<branch>/ExampleProvider/icon.png"
+
     requiresResources = false
-    language = "en"
     isCrossPlatform = true
 }
 
diff --git a/ExampleProvider/src/main/kotlin/com/example/ExampleProvider.kt b/ExampleProvider/src/main/kotlin/com/example/ExampleProvider.kt
@@ -2,7 +2,6 @@ package com.example
 
 import com.lagradost.cloudstream3.*
 import com.lagradost.cloudstream3.utils.*
-import kotlinx.coroutines.async
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import java.util.concurrent.ConcurrentHashMap
@@ -14,7 +13,13 @@ class ExampleProvider : MainAPI() {
     override var lang = "en"
     override val hasDownloadSupport = true
 
-    // Use ConcurrentHashMap for session caching if headers/cookies are needed per request.
+    // Define homepage categories
+    override val mainPage = mainPageOf(
+        "trending" to "Trending Content",
+        "latest" to "Latest Uploads"
+    )
+
+    // Per-session header/cookie cache (thread-safe).
     private val sessionHeaders = ConcurrentHashMap<String, String>()
 
     override val supportedTypes = setOf(
@@ -24,28 +29,28 @@ class ExampleProvider : MainAPI() {
     )
 
     override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
-        // Implement main page scraping here.
+        // TODO: fetch home page rows from mainUrl and map to SearchResponse items.
         val items = ArrayList<SearchResponse>()
         return newHomePageResponse(request.name, items, hasNext = true)
     }
 
     override suspend fun search(query: String): List<SearchResponse> {
-        // Implement search scraping here.
+        // TODO: call "$mainUrl/search?q=$query" and parse results.
         return emptyList()
     }
 
     override suspend fun load(url: String): LoadResponse {
-        // Implement metadata loading here.
+        // TODO: fetch metadata for the given url and return either a movie or series response.
         val title = "Example Title"
         val poster = ""
         val isMovie = true
-        
-        if (isMovie) {
-            return newMovieLoadResponse(title, url, TvType.Movie, url) {
+
+        return if (isMovie) {
+            newMovieLoadResponse(title, url, TvType.Movie, url) {
                 this.posterUrl = poster
             }
         } else {
-            return newTvSeriesLoadResponse(title, url, TvType.TvSeries, emptyList()) {
+            newTvSeriesLoadResponse(title, url, TvType.TvSeries, emptyList()) {
                 this.posterUrl = poster
             }
         }
@@ -57,19 +62,31 @@ class ExampleProvider : MainAPI() {
         subtitleCallback: (SubtitleFile) -> Unit,
         callback: (ExtractorLink) -> Unit
     ): Boolean {
-        // Use coroutines for concurrent HTTP requests when resolving links to prevent bottlenecking.
-        
-        val linksToResolve = listOf("https://server1.com/video", "https://server2.com/video")
-        
+        // TODO: collect the list of playable URLs, then resolve them concurrently.
+        val linksToResolve = listOf<String>() // e.g. listOf("$mainUrl/embed/123")
+
         coroutineScope {
             linksToResolve.forEach { link ->
                 launch {
-                    // Extract link logic here
+                    // Use the built-in extractor cascade:
                     // loadExtractor(link, subtitleCallback, callback)
+
+                    // Or build a custom ExtractorLink:
+                    // callback(
+                    //     newExtractorLink(
+                    //         source = "ExampleServer",
+                    //         name = "ExampleServer",
+                    //         url = link,
+                    //         type = ExtractorLinkType.M3U8
+                    //     ) {
+                    //         referer = mainUrl
+                    //         headers = mapOf("User-Agent" to "Mozilla/5.0")
+                    //     }
+                    // )
                 }
             }
         }
-        
+
         return true
     }
 }
diff --git a/ExampleProvider/src/main/kotlin/com/example/ExampleProviderPlugin.kt b/ExampleProvider/src/main/kotlin/com/example/ExampleProviderPlugin.kt
@@ -6,9 +6,10 @@ import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
 @CloudstreamPlugin
 class ExampleProviderPlugin : BasePlugin() {
     override fun load() {
-        // All providers should be added here
+        // Register all MainAPI providers here
         registerMainAPI(ExampleProvider())
-        // Register any custom extractors here
+
+        // Register any custom extractors here, e.g.:
         // registerExtractorAPI(ExampleExtractor())
     }
 }
diff --git a/ExampleProvider/src/test/kotlin/com/example/ExampleTest.kt b/ExampleProvider/src/test/kotlin/com/example/ExampleTest.kt
@@ -0,0 +1,63 @@
+package com.example
+
+import com.lagradost.cloudstream3.TvSeriesLoadResponse
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Test
+
+class ExampleTest {
+    private val provider = ExampleProvider()
+
+    // Replace with a valid URL from the provider
+    private val testUrl = "https://example.com/movie-page"
+
+    @Test
+    fun testProviderMetadata() = runBlocking {
+        println("[*] Loading URL: $testUrl")
+        val response = provider.load(testUrl)
+
+        // 1. Verify Core Details
+        assert(response.name.isNotBlank()) { "Error: Title card is blank!" }
+        assert(response.posterUrl?.startsWith("http") == true || response.posterUrl.isNullOrEmpty()) { "Error: Poster URL is invalid: ${response.posterUrl}" }
+
+        println("Title: ${response.name}")
+        println("Poster: ${response.posterUrl}")
+        
+        // 2. Verify Episode Indexing
+        val episodes = if (response is TvSeriesLoadResponse) {
+            response.episodes
+        } else emptyList()
+        
+        if (response is TvSeriesLoadResponse) {
+            assert(episodes.isNotEmpty()) { "Error: Mapped episode list is empty!" }
+            println("Total Mapped Episodes: ${episodes.size}")
+            
+            // 3. Verify Individual Episode Integrity
+            episodes.forEachIndexed { index, ep ->
+                val epNum = ep.episode ?: 0
+                assert(ep.name?.isNotBlank() == true || epNum > 0) { "Error: Episode $epNum is missing details!" }
+                assert(ep.data.isNotBlank()) { "Error: Playback payload for Episode $epNum is empty!" }
+            }
+        }
+    }
+
+    @Test
+    fun testVideoStreamIntegrity() = runBlocking {
+        println("[*] Fetching and verifying playback stream links directly...")
+        val response = provider.load(testUrl)
+        val epData = if (response is TvSeriesLoadResponse) {
+            response.episodes.firstOrNull()?.data
+        } else if (response is com.lagradost.cloudstream3.MovieLoadResponse) {
+            response.dataUrl
+        } else null
+        
+        assert(epData != null) { "Error: No episode/movie data payload found!" }
+        
+        val resolvedLinks = mutableListOf<ExtractorLink>()
+        provider.loadLinks(epData!!, isCasting = false, subtitleCallback = {}, callback = { link ->
+            resolvedLinks.add(link)
+        })
+        
+        println("[*] Resolved ${resolvedLinks.size} links.")
+    }
+}
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -31,6 +31,11 @@ fun Project.cloudstream(configuration: CloudstreamExtension.() -> Unit) = extens
 
 fun Project.android(configuration: LibraryExtension.() -> Unit) {
     extensions.getByName<LibraryExtension>("android").apply {
+        project.extensions.findByType(JavaPluginExtension::class.java)?.apply {
+            toolchain {
+                languageVersion.set(JavaLanguageVersion.of(17))
+            }
+        }
         configuration()
     }
 }
@@ -95,6 +100,16 @@ subprojects {
         implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.11.0")
         implementation("org.bouncycastle:bcpkix-jdk18on:1.84")
         implementation("org.jspecify:jspecify:1.0.0")
+        // Testing dependencies
+        add("testImplementation", "org.junit.jupiter:junit-jupiter-api:5.10.1")
+        add("testRuntimeOnly", "org.junit.jupiter:junit-jupiter-engine:5.10.1")
+        add("testRuntimeOnly", "org.junit.platform:junit-platform-launcher:1.10.1")
+        add("testRuntimeOnly", "org.junit.vintage:junit-vintage-engine:5.10.1")
+        add("testImplementation", files("${System.getProperty("user.home")}/.gradle/caches/cloudstream/cloudstream/cloudstream.jar"))
+    }
+
+    tasks.withType<Test> {
+        useJUnitPlatform()
     }
 }
 
diff --git a/gradle.properties b/gradle.properties
@@ -6,14 +6,10 @@
 # http://www.gradle.org/docs/current/userguide/build_environment.html
 # Specifies the JVM arguments used for the daemon process.
 # The setting is particularly useful for tweaking memory settings.
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-# When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. More details, visit
-# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true
-# AndroidX package structure to make it clearer which packages are bundled with the
-# Android operating system, and which are packaged with your app"s APK
-# https://developer.android.com/topic/libraries/support-library/androidx-rn
+org.gradle.jvmargs=-Xmx4G -Dfile.encoding=UTF-8
+org.gradle.parallel=true
 android.useAndroidX=true
-# Automatically convert third-party libraries to use AndroidX
-
+android.buildFeatures.buildConfig=true
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+android.javaCompile.suppressSourceTargetDeprecationWarning=true

Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,10 @@ import com.lagradost.cloudstream3.plugins.CloudstreamPlugin`
`6`	`6`	`@CloudstreamPlugin`
`7`	`7`	`class ExampleProviderPlugin : BasePlugin() {`
`8`	`8`	`override fun load() {`
`9`		`- // All providers should be added here`
	`9`	`+ // Register all MainAPI providers here`
`10`	`10`	`registerMainAPI(ExampleProvider())`
`11`		`- // Register any custom extractors here`
	`11`	`+`
	`12`	`+ // Register any custom extractors here, e.g.:`
`12`	`13`	`// registerExtractorAPI(ExampleExtractor())`
`13`	`14`	`}`
`14`	`15`	`}`