tests/src/com/android/customization/model/picker/color/ui/viewmodel/ColorPickerViewModelTest.kt

/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package com.android.customization.model.picker.color.ui.viewmodel

import android.content.Context
import androidx.test.filters.SmallTest
import androidx.test.platform.app.InstrumentationRegistry
import com.android.customization.picker.color.data.repository.FakeColorPickerRepository
import com.android.customization.picker.color.domain.interactor.ColorPickerInteractor
import com.android.customization.picker.color.domain.interactor.ColorPickerSnapshotRestorer
import com.android.customization.picker.color.shared.model.ColorType
import com.android.customization.picker.color.ui.viewmodel.ColorOptionViewModel
import com.android.customization.picker.color.ui.viewmodel.ColorPickerViewModel
import com.android.customization.picker.color.ui.viewmodel.ColorTypeViewModel
import com.android.wallpaper.testing.FakeSnapshotStore
import com.android.wallpaper.testing.collectLastValue
import com.google.common.truth.Truth.assertThat
import com.google.common.truth.Truth.assertWithMessage
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import org.junit.After
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4

@OptIn(ExperimentalCoroutinesApi::class)
@SmallTest
@RunWith(JUnit4::class)
class ColorPickerViewModelTest {
    private lateinit var underTest: ColorPickerViewModel
    private lateinit var repository: FakeColorPickerRepository
    private lateinit var interactor: ColorPickerInteractor
    private lateinit var store: FakeSnapshotStore

    private lateinit var context: Context
    private lateinit var testScope: TestScope

    @Before
    fun setUp() {
        context = InstrumentationRegistry.getInstrumentation().targetContext
        val testDispatcher = StandardTestDispatcher()
        testScope = TestScope(testDispatcher)
        Dispatchers.setMain(testDispatcher)
        repository = FakeColorPickerRepository(context = context)
        store = FakeSnapshotStore()

        interactor =
            ColorPickerInteractor(
                repository = repository,
                snapshotRestorer = {
                    ColorPickerSnapshotRestorer(interactor = interactor).apply {
                        runBlocking { setUpSnapshotRestorer(store = store) }
                    }
                },
            )

        underTest =
            ColorPickerViewModel.Factory(context = context, interactor = interactor)
                .create(ColorPickerViewModel::class.java)

        repository.setOptions(4, 4, ColorType.WALLPAPER_COLOR, 0)
    }

    @After
    fun tearDown() {
        Dispatchers.resetMain()
    }

    @Test
    fun `Select a color section color`() =
        testScope.runTest {
            val colorSectionOptions = collectLastValue(underTest.colorSectionOptions)

            assertColorOptionUiState(
                colorOptions = colorSectionOptions(),
                selectedColorOptionIndex = 0
            )

            colorSectionOptions()?.get(2)?.onClick?.invoke()
            assertColorOptionUiState(
                colorOptions = colorSectionOptions(),
                selectedColorOptionIndex = 2
            )

            colorSectionOptions()?.get(4)?.onClick?.invoke()
            assertColorOptionUiState(
                colorOptions = colorSectionOptions(),
                selectedColorOptionIndex = 4
            )
        }

    @Test
    fun `Select a preset color`() =
        testScope.runTest {
            val colorTypes = collectLastValue(underTest.colorTypes)
            val colorOptions = collectLastValue(underTest.colorOptions)

            // Initially, the wallpaper color tab should be selected
            assertPickerUiState(
                colorTypes = colorTypes(),
                colorOptions = colorOptions(),
                selectedColorTypeText = "Wallpaper colors",
                selectedColorOptionIndex = 0
            )

            // Select "Basic colors" tab
            colorTypes()?.get(ColorType.BASIC_COLOR)?.onClick?.invoke()
            assertPickerUiState(
                colorTypes = colorTypes(),
                colorOptions = colorOptions(),
                selectedColorTypeText = "Basic colors",
                selectedColorOptionIndex = -1
            )

            // Select a color option
            colorOptions()?.get(2)?.onClick?.invoke()

            // Check original option is no longer selected
            colorTypes()?.get(ColorType.WALLPAPER_COLOR)?.onClick?.invoke()
            assertPickerUiState(
                colorTypes = colorTypes(),
                colorOptions = colorOptions(),
                selectedColorTypeText = "Wallpaper colors",
                selectedColorOptionIndex = -1
            )

            // Check new option is selected
            colorTypes()?.get(ColorType.BASIC_COLOR)?.onClick?.invoke()
            assertPickerUiState(
                colorTypes = colorTypes(),
                colorOptions = colorOptions(),
                selectedColorTypeText = "Basic colors",
                selectedColorOptionIndex = 2
            )
        }

    /**
     * Asserts the entire picker UI state is what is expected. This includes the color type tabs and
     * the color options list.
     *
     * @param colorTypes The observed color type view-models, keyed by ColorType
     * @param colorOptions The observed color options
     * @param selectedColorTypeText The text of the color type that's expected to be selected
     * @param selectedColorOptionIndex The index of the color option that's expected to be selected,
     * -1 stands for no color option should be selected
     */
    private fun assertPickerUiState(
        colorTypes: Map<ColorType, ColorTypeViewModel>?,
        colorOptions: List<ColorOptionViewModel>?,
        selectedColorTypeText: String,
        selectedColorOptionIndex: Int,
    ) {
        assertColorTypeTabUiState(
            colorTypes = colorTypes,
            colorTypeId = ColorType.WALLPAPER_COLOR,
            isSelected = "Wallpaper colors" == selectedColorTypeText,
        )
        assertColorTypeTabUiState(
            colorTypes = colorTypes,
            colorTypeId = ColorType.BASIC_COLOR,
            isSelected = "Basic colors" == selectedColorTypeText,
        )
        assertColorOptionUiState(colorOptions, selectedColorOptionIndex)
    }

    /**
     * Asserts the picker section UI state is what is expected.
     *
     * @param colorOptions The observed color options
     * @param selectedColorOptionIndex The index of the color option that's expected to be selected,
     * -1 stands for no color option should be selected
     */
    private fun assertColorOptionUiState(
        colorOptions: List<ColorOptionViewModel>?,
        selectedColorOptionIndex: Int,
    ) {
        var foundSelectedColorOption = false
        assertThat(colorOptions).isNotNull()
        if (colorOptions != null) {
            for (i in colorOptions.indices) {
                val colorOptionHasSelectedIndex = i == selectedColorOptionIndex
                assertWithMessage(
                        "Expected color option with index \"${i}\" to have" +
                            " isSelected=$colorOptionHasSelectedIndex but it was" +
                            " ${colorOptions[i].isSelected}, num options: ${colorOptions.size}"
                    )
                    .that(colorOptions[i].isSelected)
                    .isEqualTo(colorOptionHasSelectedIndex)
                foundSelectedColorOption = foundSelectedColorOption || colorOptionHasSelectedIndex
            }
            if (selectedColorOptionIndex == -1) {
                assertWithMessage(
                        "Expected no color options to be selected, but a color option is" +
                            " selected"
                    )
                    .that(foundSelectedColorOption)
                    .isFalse()
            } else {
                assertWithMessage(
                        "Expected a color option to be selected, but no color option is" +
                            " selected"
                    )
                    .that(foundSelectedColorOption)
                    .isTrue()
            }
        }
    }

    /**
     * Asserts that a color type tab has the correct UI state.
     *
     * @param colorTypes The observed color type view-models, keyed by ColorType enum
     * @param colorTypeId the ID of the color type to assert
     * @param isSelected Whether that color type should be selected
     */
    private fun assertColorTypeTabUiState(
        colorTypes: Map<ColorType, ColorTypeViewModel>?,
        colorTypeId: ColorType,
        isSelected: Boolean,
    ) {
        val viewModel =
            colorTypes?.get(colorTypeId) ?: error("No color type with ID \"$colorTypeId\"!")
        assertThat(viewModel.isSelected).isEqualTo(isSelected)
    }
}