Implement Compose-based Error Panel, Error UI Model, and Tests for Comments

.gitignore

@@ -19,3 +19,6 @@ app/release/
 bin/
 .vscode/
 *.code-workspace
+
+# logs
+*.log

app/build.gradle

@@ -342,6 +342,10 @@ dependencies {
     androidTestImplementation libs.androidx.runner
     androidTestImplementation libs.androidx.room.testing
     androidTestImplementation libs.assertj.core
+    androidTestImplementation platform(libs.androidx.compose.bom)
+    androidTestImplementation libs.androidx.compose.ui.test.junit4
+    debugImplementation libs.androidx.compose.ui.test.manifest
+
 }
 
 static String getGitWorkingBranch() {

app/src/androidTest/java/org/schabi/newpipe/error/ErrorInfoTest.kt

@@ -0,0 +1,128 @@
+package org.schabi.newpipe.error
+
+import android.content.Context
+import android.os.Parcel
+import android.os.Parcelable
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.schabi.newpipe.R
+import org.schabi.newpipe.extractor.ServiceList
+import org.schabi.newpipe.extractor.exceptions.ParsingException
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException
+import java.io.IOException
+import java.net.SocketTimeoutException
+
+/**
+ * Instrumented tests for {@link ErrorInfo}.
+ */
+@RunWith(AndroidJUnit4::class)
+@LargeTest
+class ErrorInfoTest {
+    private val context: Context by lazy { ApplicationProvider.getApplicationContext<Context>() }
+
+    /**
+     * @param errorInfo the error info to access
+     * @return the private field errorInfo.message.stringRes using reflection
+     */
+    @Throws(NoSuchFieldException::class, IllegalAccessException::class)
+    private fun getMessageFromErrorInfo(errorInfo: ErrorInfo): Int {
+        val message = ErrorInfo::class.java.getDeclaredField("message")
+        message.isAccessible = true
+        val messageValue = message.get(errorInfo) as ErrorInfo.Companion.ErrorMessage
+
+        val stringRes = ErrorInfo.Companion.ErrorMessage::class.java.getDeclaredField("stringRes")
+        stringRes.isAccessible = true
+        return stringRes.get(messageValue) as Int
+    }
+
+    @Test
+    @Throws(NoSuchFieldException::class, IllegalAccessException::class)
+    fun errorInfoTestParcelable() {
+        val info = ErrorInfo(
+            ParsingException("Hello"),
+            UserAction.USER_REPORT,
+            "request",
+            ServiceList.YouTube.serviceId
+        )
+        // Obtain a Parcel object and write the parcelable object to it:
+        val parcel = Parcel.obtain()
+        info.writeToParcel(parcel, 0)
+        parcel.setDataPosition(0)
+        val creatorField = ErrorInfo::class.java.getDeclaredField("CREATOR")
+        val creator = creatorField.get(null)
+        check(creator is Parcelable.Creator<*>)
+        val infoFromParcel = requireNotNull(
+            creator.createFromParcel(parcel) as? ErrorInfo
+        )
+        assertTrue(
+            infoFromParcel.stackTraces.contentToString()
+                .contains(ErrorInfoTest::class.java.simpleName)
+        )
+        assertEquals(UserAction.USER_REPORT, infoFromParcel.userAction)
+        assertEquals(
+            ServiceList.YouTube.serviceInfo.name,
+            infoFromParcel.getServiceName()
+        )
+        assertEquals("request", infoFromParcel.request)
+        assertEquals(R.string.parsing_error, getMessageFromErrorInfo(infoFromParcel))
+
+        parcel.recycle()
+    }
+
+    /**
+     * Test: Network error on initial load (Resource.Error)
+     */
+
+    @Test
+    fun testInitialCommentNetworkError() {
+        val errorInfo = ErrorInfo(
+            throwable = SocketTimeoutException("Connection timeout"),
+            userAction = UserAction.REQUESTED_COMMENTS,
+            request = "comments"
+        )
+        assertEquals(context.getString(R.string.network_error), errorInfo.getMessage(context))
+        assertTrue(errorInfo.isReportable)
+        assertTrue(errorInfo.isRetryable)
+        assertNull(errorInfo.recaptchaUrl)
+    }
+
+    /**
+     * Test: Network error on paging (LoadState.Error)
+     */
+    @Test
+    fun testPagingNetworkError() {
+        val errorInfo = ErrorInfo(
+            throwable = IOException("Paging failed"),
+            userAction = UserAction.REQUESTED_COMMENTS,
+            request = "comments"
+        )
+        assertEquals(context.getString(R.string.network_error), errorInfo.getMessage(context))
+        assertTrue(errorInfo.isReportable)
+        assertTrue(errorInfo.isRetryable)
+        assertNull(errorInfo.recaptchaUrl)
+    }
+
+    /**
+     * Test: ReCaptcha during comments load
+     */
+    @Test
+    fun testReCaptchaDuringComments() {
+        val url = "https://www.google.com/recaptcha/api/fallback?k=test"
+        val errorInfo = ErrorInfo(
+            throwable = ReCaptchaException("ReCaptcha needed", url),
+            userAction = UserAction.REQUESTED_COMMENTS,
+            request = "comments"
+        )
+        assertEquals(context.getString(R.string.recaptcha_request_toast), errorInfo.getMessage(context))
+        assertEquals(url, errorInfo.recaptchaUrl)
+        assertFalse(errorInfo.isReportable)
+        assertTrue(errorInfo.isRetryable)
+    }
+}

app/src/androidTest/java/org/schabi/newpipe/ui/components/common/ErrorPanelTest.kt

@@ -0,0 +1,126 @@
+package org.schabi.newpipe.ui.components.common
+
+import androidx.activity.ComponentActivity
+import androidx.annotation.StringRes
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.schabi.newpipe.R
+import org.schabi.newpipe.error.ErrorInfo
+import org.schabi.newpipe.error.UserAction
+import org.schabi.newpipe.extractor.exceptions.ContentNotAvailableException
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException
+import org.schabi.newpipe.ui.theme.AppTheme
+import java.net.UnknownHostException
+
+@RunWith(AndroidJUnit4::class)
+class ErrorPanelTest {
+    @get:Rule
+    val composeRule = createAndroidComposeRule<ComponentActivity>()
+
+    private fun setErrorPanel(errorInfo: ErrorInfo, onRetry: (() -> Unit)? = null) {
+        composeRule.setContent {
+            AppTheme {
+                ErrorPanel(errorInfo = errorInfo, onRetry = onRetry)
+            }
+        }
+    }
+    private fun text(@StringRes id: Int) = composeRule.activity.getString(id)
+
+    /**
+     * Test Network Error
+     */
+    @Test
+    fun testNetworkErrorShowsRetryWithoutReportButton() {
+        val networkErrorInfo = ErrorInfo(
+            throwable = UnknownHostException("offline"),
+            userAction = UserAction.REQUESTED_STREAM,
+            request = "https://example.com/watch?v=foo"
+        )
+
+        setErrorPanel(networkErrorInfo, onRetry = {})
+        composeRule.onNodeWithText(text(R.string.network_error)).assertIsDisplayed()
+        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true).assertIsDisplayed()
+        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
+            .assertDoesNotExist()
+        composeRule.onNodeWithText(text(R.string.recaptcha_solve), ignoreCase = true)
+            .assertDoesNotExist()
+    }
+
+    /**
+     * Test Unexpected Error, Shows Report and Retry buttons
+     */
+    @Test
+    fun unexpectedErrorShowsReportAndRetryButtons() {
+        val unexpectedErrorInfo = ErrorInfo(
+            throwable = RuntimeException("Unexpected error"),
+            userAction = UserAction.REQUESTED_STREAM,
+            request = "https://example.com/watch?v=bar"
+        )
+
+        setErrorPanel(unexpectedErrorInfo, onRetry = {})
+        composeRule.onNodeWithText(text(R.string.error_snackbar_message)).assertIsDisplayed()
+        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true).assertIsDisplayed()
+        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
+            .assertIsDisplayed()
+    }
+
+    /**
+     * Test Recaptcha Error shows solve, retry and open in browser buttons
+     */
+    @Test
+    fun recaptchaErrorShowsSolveAndRetryOpenInBrowserButtons() {
+        var retryClicked = false
+        val recaptchaErrorInfo = ErrorInfo(
+            throwable = ReCaptchaException(
+                "Recaptcha required",
+                "https://example.com/captcha"
+            ),
+            userAction = UserAction.REQUESTED_STREAM,
+            request = "https://example.com/watch?v=baz",
+            openInBrowserUrl = "https://example.com/watch?v=baz"
+        )
+
+        setErrorPanel(
+            errorInfo = recaptchaErrorInfo,
+            onRetry = { retryClicked = true }
+
+        )
+        composeRule.onNodeWithText(text(R.string.recaptcha_solve), ignoreCase = true)
+            .assertIsDisplayed()
+        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true)
+            .assertIsDisplayed()
+            .performClick()
+        composeRule.onNodeWithText(text(R.string.open_in_browser), ignoreCase = true)
+            .assertIsDisplayed()
+        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
+            .assertDoesNotExist()
+        assert(retryClicked) { "onRetry callback should have been invoked" }
+    }
+
+    /**
+     * Test Content Not Available Error hides retry button
+     */
+    @Test
+    fun testNonRetryableErrorHidesRetryAndReportButtons() {
+        val contentNotAvailable = ErrorInfo(
+            throwable = ContentNotAvailableException("Video has been removed"),
+            userAction = UserAction.REQUESTED_STREAM,
+            request = "https://example.com/watch?v=qux"
+        )
+
+        setErrorPanel(contentNotAvailable)
+
+        composeRule.onNodeWithText(text(R.string.content_not_available))
+            .assertIsDisplayed()
+        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true)
+            .assertDoesNotExist()
+        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
+            .assertDoesNotExist()
+    }
+}