grain.social/grain-android

Switch repository

Loading…

package social.grain

import androidx.test.ext.junit.runners.AndroidJUnit4
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.Json
import okhttp3.OkHttpClient
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith
import social.grain.data.api.XrpcClient
import social.grain.data.api.getCommentThread
import social.grain.data.api.getFeed
import social.grain.data.api.getGallery
import social.grain.data.auth.AuthManager
import java.util.concurrent.TimeUnit

/**
 * Decodes live gallery-detail and comment responses into the ported models.
 *
 * Same class of risk the feed models carried: a field typed wrong here shows up
 * only as an empty comment sheet with a decode error buried in the log.
 */
@RunWith(AndroidJUnit4::class)
class CommentDecodeTest {

    private val client = XrpcClient(
        baseUrl = AuthManager.SERVER_URL,
        http = OkHttpClient.Builder()
            .connectTimeout(20, TimeUnit.SECONDS)
            .readTimeout(20, TimeUnit.SECONDS)
            .build(),
        json = Json {
            ignoreUnknownKeys = true
            explicitNulls = false
            coerceInputValues = true
        },
    )

    @Test
    fun galleryDetailDecodesForARealGallery() = runBlocking {
        val uri = client.getFeed(feed = "recent", limit = 1).items.orEmpty().first().uri

        val gallery = client.getGallery(uri).gallery
        assertEquals(uri, gallery.uri)
        assertTrue("Creator DID missing", gallery.creator.did.startsWith("did:"))
        assertTrue("Detail returned no photos", gallery.items.orEmpty().isNotEmpty())
    }

    @Test
    fun commentThreadDecodesAndRepliesNameTheirRoot() = runBlocking {
        // Walk the feed for a gallery that actually has comments rather than
        // asserting against whatever happens to be newest.
        val withComments = client.getFeed(feed = "recent", limit = 60).items.orEmpty()
            .firstOrNull { (it.commentCount ?: 0) > 0 }

        if (withComments == null) {
            // Nothing to assert against; still exercise the decode path so a
            // broken response type fails rather than silently skipping.
            client.getCommentThread(client.getFeed(feed = "recent", limit = 1).items!!.first().uri)
            return@runBlocking
        }

        val thread = client.getCommentThread(withComments.uri)
        assertTrue("Gallery reported comments but the thread was empty", thread.comments.isNotEmpty())

        val uris = thread.comments.map { it.uri }.toSet()
        for (comment in thread.comments) {
            assertTrue("Comment URI should be an at:// URI", comment.uri.startsWith("at://"))
            assertTrue("Comment author DID missing", comment.author.did.startsWith("did:"))
            comment.replyTo?.let {
                assertTrue("replyTo should be an at:// URI, was '$it'", it.startsWith("at://"))
            }
            // Exercise the facet path against whatever real records contain.
            comment.facets?.forEach { it.parsedFeatures }
        }
        assertEquals("Comment URIs should be unique", thread.comments.size, uris.size)
    }
}