Merge "Add test for MessageBuilder" into main

/*

 * Copyright (C) 2025 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.documentsui.ui

import android.content.Context

import android.content.res.Resources

import android.net.Uri

import android.provider.DocumentsContract.Document.MIME_TYPE_DIR

import androidx.test.filters.SmallTest

import com.android.documentsui.OperationDialogFragment.DIALOG_TYPE_CONVERTED

import com.android.documentsui.OperationDialogFragment.DIALOG_TYPE_FAILURE

import com.android.documentsui.R

import com.android.documentsui.base.DocumentInfo

import com.android.documentsui.services.FileOperationService.OPERATION_COMPRESS

import com.android.documentsui.services.FileOperationService.OPERATION_COPY

import com.android.documentsui.services.FileOperationService.OPERATION_DELETE

import com.android.documentsui.services.FileOperationService.OPERATION_EXTRACT

import com.android.documentsui.services.FileOperationService.OPERATION_MOVE

import com.android.documentsui.services.FileOperationService.OPERATION_UNKNOWN

import org.junit.Assert.assertEquals

import org.junit.Before

import org.junit.Test

import org.junit.runner.RunWith

import org.junit.runners.Parameterized

import org.junit.runners.Suite

import org.junit.runners.Suite.SuiteClasses

import org.mockito.ArgumentMatchers.anyString

import org.mockito.Mock

import org.mockito.Mockito.eq

import org.mockito.Mockito.`when` as whenever

import org.mockito.MockitoAnnotations

@SmallTest

@RunWith(Suite::class)

@SuiteClasses(

    MessageBuilderTest.GenerateDeleteMessage::class,

    MessageBuilderTest.GenerateListMessage::class

)

open class MessageBuilderTest() {

    companion object {

        const val EXPECTED_MESSAGE = "Delete message"

    }

    class GenerateDeleteMessage() {

        private lateinit var messageBuilder: MessageBuilder

        @Mock

        private lateinit var resources: Resources

        @Mock

        private lateinit var context: Context

        @Before

        fun setUp() {

            MockitoAnnotations.openMocks(this)

            whenever(context.resources).thenReturn(resources)

            messageBuilder = MessageBuilder(context)

        }

        private fun assertDeleteMessage(docInfo: DocumentInfo, resId: Int) {

            whenever(

                resources.getString(

                    eq(resId),

                    eq(docInfo.displayName)

                )

            ).thenReturn(EXPECTED_MESSAGE)

            assertEquals(messageBuilder.generateDeleteMessage(listOf(docInfo)), EXPECTED_MESSAGE)

        }

        private fun assertQuantityDeleteMessage(docInfos: List<DocumentInfo>, resId: Int) {

            whenever(

                resources.getQuantityString(

                    eq(resId),

                    eq(docInfos.size),

                    eq(docInfos.size)

                )

            ).thenReturn(EXPECTED_MESSAGE)

            assertEquals(messageBuilder.generateDeleteMessage(docInfos), EXPECTED_MESSAGE)

        }

        @Test

        fun testGenerateDeleteMessage_singleFile() {

            assertDeleteMessage(

                createFile("Test doc"),

                R.string.delete_filename_confirmation_message

            )

        }

        @Test

        fun testGenerateDeleteMessage_singleDirectory() {

            assertDeleteMessage(

                createDirectory("Test doc"),

                R.string.delete_foldername_confirmation_message

            )

        }

        @Test

        fun testGenerateDeleteMessage_multipleFiles() {

            assertQuantityDeleteMessage(

                listOf(createFile("File 1"), createFile("File 2")),

                R.plurals.delete_files_confirmation_message

            )

        }

        @Test

        fun testGenerateDeleteMessage_multipleDirectories() {

            assertQuantityDeleteMessage(

                listOf(

                    createDirectory("Directory 1"),

                    createDirectory("Directory 2")

                ),

                R.plurals.delete_folders_confirmation_message

            )

        }

        @Test

        fun testGenerateDeleteMessage_mixedFilesAndDirectories() {

            assertQuantityDeleteMessage(

                listOf(createFile("File 1"), createDirectory("Directory 1")),

                R.plurals.delete_items_confirmation_message

            )

        }

    }

    @RunWith(Parameterized::class)

    class GenerateListMessage() {

        private lateinit var messageBuilder: MessageBuilder

        @Mock

        private lateinit var resources: Resources

        @Mock

        private lateinit var context: Context

        @Before

        fun setUp() {

            MockitoAnnotations.openMocks(this)

            whenever(context.resources).thenReturn(resources)

            messageBuilder = MessageBuilder(context)

        }

        data class ListMessageData(

            val dialogType: Int,

            val opType: Int = OPERATION_UNKNOWN,

            val resId: Int

        )

        companion object {

            @Parameterized.Parameters(name = "{0}")

            @JvmStatic

            fun parameters() =

                listOf(

                    ListMessageData(

                        dialogType = DIALOG_TYPE_CONVERTED,

                        resId = R.plurals.copy_converted_warning_content,

                    ),

                    ListMessageData(

                        dialogType = DIALOG_TYPE_FAILURE,

                        opType = OPERATION_COPY,

                        resId = R.plurals.copy_failure_alert_content,

                    ),

                    ListMessageData(

                        dialogType = DIALOG_TYPE_FAILURE,

                        opType = OPERATION_COMPRESS,

                        resId = R.plurals.compress_failure_alert_content,

                    ),

                    ListMessageData(

                        dialogType = DIALOG_TYPE_FAILURE,

                        opType = OPERATION_EXTRACT,

                        resId = R.plurals.extract_failure_alert_content,

                    ),

                    ListMessageData(

                        dialogType = DIALOG_TYPE_FAILURE,

                        opType = OPERATION_DELETE,

                        resId = R.plurals.delete_failure_alert_content,

                    ),

                    ListMessageData(

                        dialogType = DIALOG_TYPE_FAILURE,

                        opType = OPERATION_MOVE,

                        resId = R.plurals.move_failure_alert_content,

                    ),

                )

        }

        @Parameterized.Parameter(0)

        lateinit var testData: ListMessageData

        @Test

        fun testGenerateListMessage() {

            whenever(

                resources.getQuantityString(

                    eq(testData.resId),

                    eq(2),

                    anyString(),

                )

            ).thenReturn(EXPECTED_MESSAGE)

            assertEquals(

                messageBuilder.generateListMessage(

                    testData.dialogType,

                    testData.opType,

                    listOf(createFile("File 1")),

                    listOf(Uri.parse("content://random-uri")),

                ),

                EXPECTED_MESSAGE

            )

        }

    }

}

fun createFile(displayName: String): DocumentInfo {

    val doc = DocumentInfo()

    doc.displayName = displayName

    return doc

}

fun createDirectory(displayName: String): DocumentInfo {

    val doc = DocumentInfo()

    doc.displayName = displayName

    doc.mimeType = MIME_TYPE_DIR

    return doc

}