tauri-plugin-healthkit 0.1.3

package life.thephage.healthkit

import org.junit.Test
import org.junit.Assert.*

/**
 * HealthPermissionUtil のユニットテスト
 */
class HealthPermissionUtilTest {

    // ========================================================================
    // toFullPermission Tests
    // ========================================================================

    @Test
    fun toFullPermission_steps_returnsCorrectPermission() {
        val readResult = HealthPermissionUtil.toFullPermission("READ_STEPS")
        val writeResult = HealthPermissionUtil.toFullPermission("WRITE_STEPS")

        assertNotNull("READ_STEPS should return a valid permission", readResult)
        assertNotNull("WRITE_STEPS should return a valid permission", writeResult)
        assertTrue("READ_STEPS should contain 'READ'", readResult!!.contains("READ"))
        assertTrue("WRITE_STEPS should contain 'WRITE'", writeResult!!.contains("WRITE"))
    }

    @Test
    fun toFullPermission_heartRate_returnsCorrectPermission() {
        val readResult = HealthPermissionUtil.toFullPermission("READ_HEART_RATE")
        val writeResult = HealthPermissionUtil.toFullPermission("WRITE_HEART_RATE")

        assertNotNull("READ_HEART_RATE should return a valid permission", readResult)
        assertNotNull("WRITE_HEART_RATE should return a valid permission", writeResult)
    }

    @Test
    fun toFullPermission_weight_returnsCorrectPermission() {
        val readResult = HealthPermissionUtil.toFullPermission("READ_WEIGHT")
        val writeResult = HealthPermissionUtil.toFullPermission("WRITE_WEIGHT")

        assertNotNull("READ_WEIGHT should return a valid permission", readResult)
        assertNotNull("WRITE_WEIGHT should return a valid permission", writeResult)
    }

    @Test
    fun toFullPermission_sleep_returnsCorrectPermission() {
        val readResult = HealthPermissionUtil.toFullPermission("READ_SLEEP")
        val writeResult = HealthPermissionUtil.toFullPermission("WRITE_SLEEP")

        assertNotNull("READ_SLEEP should return a valid permission", readResult)
        assertNotNull("WRITE_SLEEP should return a valid permission", writeResult)
    }

    @Test
    fun toFullPermission_exercise_returnsCorrectPermission() {
        val readResult = HealthPermissionUtil.toFullPermission("READ_EXERCISE")
        val writeResult = HealthPermissionUtil.toFullPermission("WRITE_EXERCISE")

        assertNotNull("READ_EXERCISE should return a valid permission", readResult)
        assertNotNull("WRITE_EXERCISE should return a valid permission", writeResult)
    }

    @Test
    fun toFullPermission_invalidPermission_returnsNull() {
        val result = HealthPermissionUtil.toFullPermission("INVALID_PERMISSION")
        assertNull("Invalid permission should return null", result)
    }

    @Test
    fun toFullPermission_emptyString_returnsNull() {
        val result = HealthPermissionUtil.toFullPermission("")
        assertNull("Empty string should return null", result)
    }

    // ========================================================================
    // toShortName Tests
    // ========================================================================

    @Test
    fun toShortName_roundTrip_returnsOriginal() {
        val permissions = listOf(
            "READ_STEPS", "WRITE_STEPS",
            "READ_HEART_RATE", "WRITE_HEART_RATE",
            "READ_WEIGHT", "WRITE_WEIGHT",
            "READ_SLEEP", "WRITE_SLEEP",
            "READ_EXERCISE", "WRITE_EXERCISE"
        )

        for (shortName in permissions) {
            val fullPermission = HealthPermissionUtil.toFullPermission(shortName)
            assertNotNull("$shortName should have a full permission", fullPermission)

            val backToShort = HealthPermissionUtil.toShortName(fullPermission!!)
            assertEquals("Round trip should return original: $shortName", shortName, backToShort)
        }
    }

    // ========================================================================
    // toFullPermissions Tests
    // ========================================================================

    @Test
    fun toFullPermissions_multiplePermissions_returnsSet() {
        val shortNames = listOf("READ_STEPS", "READ_HEART_RATE", "WRITE_WEIGHT")
        val result = HealthPermissionUtil.toFullPermissions(shortNames)

        assertEquals("Should return 3 permissions", 3, result.size)
    }

    @Test
    fun toFullPermissions_withInvalidPermission_filtersOut() {
        val shortNames = listOf("READ_STEPS", "INVALID", "READ_HEART_RATE")
        val result = HealthPermissionUtil.toFullPermissions(shortNames)

        assertEquals("Should return 2 valid permissions", 2, result.size)
    }

    @Test
    fun toFullPermissions_emptyList_returnsEmptySet() {
        val result = HealthPermissionUtil.toFullPermissions(emptyList())
        assertTrue("Empty input should return empty set", result.isEmpty())
    }

    @Test
    fun toFullPermissions_duplicates_returnsUniqueSet() {
        val shortNames = listOf("READ_STEPS", "READ_STEPS", "READ_STEPS")
        val result = HealthPermissionUtil.toFullPermissions(shortNames)

        assertEquals("Duplicates should be removed", 1, result.size)
    }

    // ========================================================================
    // toShortNames Tests
    // ========================================================================

    @Test
    fun toShortNames_multiplePermissions_returnsList() {
        val shortNames = listOf("READ_STEPS", "READ_HEART_RATE")
        val fullPermissions = HealthPermissionUtil.toFullPermissions(shortNames)
        val result = HealthPermissionUtil.toShortNames(fullPermissions)

        assertEquals("Should return 2 short names", 2, result.size)
        assertTrue("Should contain READ_STEPS", result.contains("READ_STEPS"))
        assertTrue("Should contain READ_HEART_RATE", result.contains("READ_HEART_RATE"))
    }

    @Test
    fun toShortNames_emptySet_returnsEmptyList() {
        val result = HealthPermissionUtil.toShortNames(emptySet())
        assertTrue("Empty input should return empty list", result.isEmpty())
    }

    // ========================================================================
    // All Permissions Coverage Test
    // ========================================================================

    @Test
    fun allPermissions_areSupported() {
        val allShortNames = listOf(
            "READ_STEPS", "WRITE_STEPS",
            "READ_HEART_RATE", "WRITE_HEART_RATE",
            "READ_WEIGHT", "WRITE_WEIGHT",
            "READ_SLEEP", "WRITE_SLEEP",
            "READ_EXERCISE", "WRITE_EXERCISE"
        )

        for (shortName in allShortNames) {
            val fullPermission = HealthPermissionUtil.toFullPermission(shortName)
            assertNotNull("$shortName should be supported", fullPermission)
        }
    }
}