fenix/app/src/test/java/org/mozilla/fenix/settings/logins/SyncLoginsPreferenceViewTest.kt

package org.mozilla.fenix.settings.logins

import android.content.Context
import androidx.lifecycle.LifecycleOwner
import androidx.navigation.NavController
import androidx.preference.Preference
import io.mockk.CapturingSlot
import io.mockk.MockKAnnotations
import io.mockk.Runs
import io.mockk.every
import io.mockk.impl.annotations.MockK
import io.mockk.just
import io.mockk.mockk
import io.mockk.mockkConstructor
import io.mockk.mockkStatic
import io.mockk.slot
import io.mockk.unmockkConstructor
import io.mockk.unmockkStatic
import io.mockk.verify
import mozilla.components.concept.sync.AccountObserver
import mozilla.components.feature.accounts.FirefoxAccountsAuthFeature
import mozilla.components.service.fxa.SyncEngine
import mozilla.components.service.fxa.manager.FxaAccountManager
import mozilla.components.service.fxa.manager.SyncEnginesStorage
import mozilla.components.support.ktx.android.content.hasCamera
import org.junit.After
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.mozilla.fenix.R
import org.mozilla.fenix.components.metrics.Event
import org.mozilla.fenix.components.metrics.MetricController
import org.mozilla.fenix.settings.logins.fragment.SavedLoginsAuthFragmentDirections

class SyncLoginsPreferenceViewTest {

    @MockK private lateinit var syncLoginsPreference: Preference
    @MockK private lateinit var lifecycleOwner: LifecycleOwner
    @MockK private lateinit var accountManager: FxaAccountManager
    @MockK(relaxed = true) private lateinit var navController: NavController
    @MockK(relaxed = true) private lateinit var accountsAuthFeature: FirefoxAccountsAuthFeature
    @MockK(relaxed = true) private lateinit var metrics: MetricController
    private lateinit var accountObserver: CapturingSlot<AccountObserver>
    private lateinit var clickListener: CapturingSlot<Preference.OnPreferenceClickListener>

    @Before
    fun setup() {
        MockKAnnotations.init(this)
        mockkConstructor(SyncEnginesStorage::class)

        accountObserver = slot()
        clickListener = slot()
        val context = mockk<Context> {
            every { getString(R.string.preferences_passwords_sync_logins_reconnect) } returns "Reconnect"
            every { getString(R.string.preferences_passwords_sync_logins_sign_in) } returns "Sign in to Sync"
            every { getString(R.string.preferences_passwords_sync_logins_on) } returns "On"
            every { getString(R.string.preferences_passwords_sync_logins_off) } returns "Off"
        }

        every { syncLoginsPreference.summary = any() } just Runs
        every { syncLoginsPreference.onPreferenceClickListener = capture(clickListener) } just Runs
        every { syncLoginsPreference.context } returns context
        every { accountManager.register(capture(accountObserver), owner = lifecycleOwner) } just Runs
        every { anyConstructed<SyncEnginesStorage>().getStatus() } returns emptyMap()
    }

    @After
    fun teardown() {
        unmockkConstructor(SyncEnginesStorage::class)
    }

    @Test
    fun `needs reauth ui on init`() {
        every { accountManager.authenticatedAccount() } returns mockk()
        every { accountManager.accountNeedsReauth() } returns true
        createView()

        verify { syncLoginsPreference.summary = "Reconnect" }
        assertTrue(clickListener.captured.onPreferenceClick(syncLoginsPreference))

        verify {
            navController.navigate(
                SavedLoginsAuthFragmentDirections.actionGlobalAccountProblemFragment()
            )
        }
    }

    @Test
    fun `needs reauth ui on init even if null account`() {
        every { accountManager.authenticatedAccount() } returns null
        every { accountManager.accountNeedsReauth() } returns true
        createView()

        verify { syncLoginsPreference.summary = "Reconnect" }
    }

    @Test
    fun `needs login if account does not exist and device has camera`() {
        every { accountManager.authenticatedAccount() } returns null
        every { accountManager.accountNeedsReauth() } returns false
        mockkStatic("mozilla.components.support.ktx.android.content.ContextKt")
        every { any<Context>().hasCamera() } returns true
        createView()

        verify { syncLoginsPreference.summary = "Sign in to Sync" }
        assertTrue(clickListener.captured.onPreferenceClick(syncLoginsPreference))

        verify {
            navController.navigate(
                SavedLoginsAuthFragmentDirections.actionSavedLoginsAuthFragmentToTurnOnSyncFragment()
            )
        }

        unmockkStatic("mozilla.components.support.ktx.android.content.ContextKt")
    }

    @Test
    fun `needs login if account does not exist and device does not have camera`() {
        every { accountManager.authenticatedAccount() } returns null
        every { accountManager.accountNeedsReauth() } returns false
        createView()
        mockkStatic("mozilla.components.support.ktx.android.content.ContextKt")
        every { any<Context>().hasCamera() } returns false

        verify { syncLoginsPreference.summary = "Sign in to Sync" }
        assertTrue(clickListener.captured.onPreferenceClick(syncLoginsPreference))
        verify {
            accountsAuthFeature.beginAuthentication(any())
            metrics.track(Event.SyncAuthUseEmail)
        }

        unmockkStatic("mozilla.components.support.ktx.android.content.ContextKt")
    }

    @Test
    fun `show status for existing account`() {
        every { accountManager.authenticatedAccount() } returns mockk()
        every { accountManager.accountNeedsReauth() } returns false
        createView()

        verify { syncLoginsPreference.summary = "Off" }
        assertTrue(clickListener.captured.onPreferenceClick(syncLoginsPreference))

        verify {
            navController.navigate(
                SavedLoginsAuthFragmentDirections.actionGlobalAccountSettingsFragment()
            )
        }
    }

    @Test
    fun `show status for existing account with passwords`() {
        every { anyConstructed<SyncEnginesStorage>().getStatus() } returns mapOf(
            SyncEngine.Passwords to true
        )
        every { accountManager.authenticatedAccount() } returns mockk()
        every { accountManager.accountNeedsReauth() } returns false
        createView()

        verify { syncLoginsPreference.summary = "On" }
        assertTrue(clickListener.captured.onPreferenceClick(syncLoginsPreference))

        verify {
            navController.navigate(
                SavedLoginsAuthFragmentDirections.actionGlobalAccountSettingsFragment()
            )
        }
    }

    private fun createView() = SyncLoginsPreferenceView(
        syncLoginsPreference,
        lifecycleOwner,
        accountManager,
        navController,
        accountsAuthFeature,
        metrics
    )
}