grain.social/grain-android

Switch repository

Loading…

package social.grain

import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import social.grain.data.api.ActorSuggestion
import social.grain.feature.login.LoginViewModel
import social.grain.support.STUB_ISSUER
import social.grain.support.stubSignIn
import social.grain.support.Harness
import social.grain.support.MainDispatcherRule
import social.grain.support.applySnapshot
import social.grain.support.awaitCall
import social.grain.support.awaitValue
import social.grain.support.settle
import social.grain.support.type

/**
 * The sign-in screen: a handle field with a typeahead, and the PAR call behind
 * the button.
 *
 * The subtle one is that choosing a suggestion writes it into the field, which
 * the collector watching the field sees as a fresh query — without the settled
 * handle it would reopen the suggestion list under the reader's finger.
 */
@RunWith(AndroidJUnit4::class)
class LoginViewModelTest {

    @get:Rule
    val mainDispatcher = MainDispatcherRule()

    private lateinit var harness: Harness

    private val typeahead = "social.grain.actor.searchActorsTypeahead"

    @Before
    fun setUp() {
        harness = Harness(signedIn = false)
        harness.server
            .on(
                typeahead,
                """{"actors":[{"did":"did:plc:alice","handle":"alice.grain.social"}]}""",
            )
        harness.server.stubSignIn(did = "did:plc:alice", handle = "alice.grain.social")
    }

    @After
    fun tearDown() = harness.tearDown()

    private fun viewModel() = LoginViewModel(harness.auth, harness.client)

    @Test
    fun typingAtLeastTwoCharactersFetchesSuggestions() {
        val model = viewModel()
        model.handleState.type("al")

        val state = model.state.awaitValue("the suggestions") { it.suggestions.isNotEmpty() }
        assertEquals("alice.grain.social", state.suggestions.single().handle)
        assertEquals("al", harness.server.lastCall(typeahead).params["q"])
    }

    @Test
    fun theLeadingAtIsStrippedBeforeAsking() {
        val model = viewModel()
        model.handleState.type("@alice")

        harness.server.awaitCall(typeahead)
        assertEquals("alice", harness.server.lastCall(typeahead).params["q"])
    }

    @Test
    fun oneCharacterIsNotEnoughToSuggestAnything() {
        val model = viewModel()
        model.handleState.type("a")
        settle()
        Thread.sleep(500)

        assertEquals(0, harness.server.countOf(typeahead))
        assertTrue(model.state.value.suggestions.isEmpty())
    }

    @Test
    fun choosingASuggestionFillsTheFieldWithoutReopeningTheList() {
        val model = viewModel()
        model.handleState.type("al")
        model.state.awaitValue("the suggestions") { it.suggestions.isNotEmpty() }
        val before = harness.server.countOf(typeahead)

        model.chooseSuggestion(ActorSuggestion(did = "did:plc:alice", handle = "alice.grain.social"))
        applySnapshot()
        Thread.sleep(500)
        settle()

        assertEquals("alice.grain.social", model.handleState.text.toString())
        assertTrue(model.state.value.suggestions.isEmpty())
        assertEquals("The chosen handle isn't looked up again", before, harness.server.countOf(typeahead))
    }

    @Test
    fun dismissingTheListKeepsItClosedForWhatIsAlreadyTyped() {
        val model = viewModel()
        model.handleState.type("alice.grain.social")
        model.state.awaitValue("the suggestions") { it.suggestions.isNotEmpty() }

        model.clearSuggestions()
        applySnapshot()
        Thread.sleep(500)

        assertTrue(model.state.value.suggestions.isEmpty())
    }

    @Test
    fun signingInRunsParAndHandsBackTheUrlToOpen() {
        val model = viewModel()
        model.handleState.type("alice.grain.social")

        model.signIn()

        val state = model.state.awaitValue("the authorize url") { it.authorizeUrl != null }
        assertTrue(state.authorizeUrl!!.startsWith("$STUB_ISSUER/oauth/authorize"))
        assertTrue(state.authorizeUrl!!.contains("request_uri=urn"))
        assertFalse(state.isLoading)

        val par = harness.server.lastCall("par")
        assertTrue(par.body.contains("code_challenge_method=S256"))
        assertTrue(par.body.contains("login_hint=alice.grain.social"))
        assertEquals(3, par.dpopProof!!.split('.').size)

        model.consumeAuthorizeUrl()
        assertNull("The url is consumed so a recomposition can't reopen the browser", model.state.value.authorizeUrl)
    }

    @Test
    fun creatingAnAccountAsksForTheSignUpPageInstead() {
        val model = viewModel()
        model.signIn(createAccount = true)
        model.state.awaitValue("the authorize url") { it.authorizeUrl != null }

        val par = harness.server.lastCall("par")
        assertTrue(par.body.contains("prompt=create"))
    }

    @Test
    fun aParThatFailsReportsItAndLeavesTheButtonUsable() {
        harness.server.on("par", """{"error":"no"}""", code = 500)
        val model = viewModel()
        model.handleState.type("alice.grain.social")

        model.signIn()

        val state = model.state.awaitValue("the error") { it.errorMessage != null }
        assertFalse(state.isLoading)
        assertNull(state.authorizeUrl)

        model.dismissError()
        assertNull(model.state.value.errorMessage)
    }

    @Test
    fun aSecondTapWhileTheFirstIsInFlightIsIgnored() {
        harness.server.on("par", """{"request_uri":"urn:a"}""")
        val model = viewModel()
        model.handleState.type("alice.grain.social")

        model.signIn()
        model.signIn()

        model.state.awaitValue("the authorize url") { it.authorizeUrl != null }
        assertEquals(1, harness.server.countOf("par"))
    }

    @Test
    fun signingInWithNoHandleAsksForOne() {
        val model = viewModel()

        model.signIn()

        val state = model.state.awaitValue("the error") { it.errorMessage != null }
        assertEquals("Enter your handle to sign in.", state.errorMessage)
        assertEquals(0, harness.server.countOf("par"))
    }

    @Test
    fun thereIsNoReauthReasonOnAPlainSignIn() {
        assertNull(viewModel().reauthReason)
    }
}