rafsanjani / superdiary Goto Github PK

package com.foreverrafs.superdiary.data

import app.cash.turbine.test
import assertk.assertThat
import assertk.assertions.isNotEmpty
import com.aallam.openai.api.chat.ChatChoice
import com.aallam.openai.api.chat.ChatChunk
import com.aallam.openai.api.chat.ChatCompletion
import com.aallam.openai.api.chat.ChatCompletionChunk
import com.aallam.openai.api.chat.ChatDelta
import com.aallam.openai.api.chat.ChatMessage
import com.aallam.openai.api.chat.ChatRole
import com.aallam.openai.api.model.ModelId
import com.aallam.openai.client.OpenAI
import com.foreverrafs.superdiary.data.diaryai.OpenDiaryAI
import io.mockative.Mock
import io.mockative.any
import io.mockative.coEvery
import io.mockative.every
import io.mockative.mock
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Ignore
import kotlin.test.Test
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain

// TODO: Fix OpenDiaryAiTest and get it to pass
@OptIn(ExperimentalCoroutinesApi::class)
@Ignore
class OpenDiaryAiTest {
    @Mock
    private val openAI: OpenAI = mock(OpenAI::class)

    private val openDiaryAI = OpenDiaryAI(openAI)

    private val chatCompletionChunk = ChatCompletionChunk(
        id = "id",
        created = 1230,
        model = ModelId("asdf"),
        usage = null,
        choices = listOf(
            ChatChunk(0, ChatDelta(content = "summary"), null),
        ),
    )

    private val chatCompletion = ChatCompletion(
        id = "id",
        created = 1200L,
        model = ModelId(""),
        usage = null,
        choices = listOf(
            ChatChoice(
                index = 0,
                message = ChatMessage(role = ChatRole.Assistant, content = "some message response"),
            ),
        ),
    )

    @BeforeTest
    fun setup() {
        Dispatchers.setMain(TestAppDispatchers.main)
        //        every { openAI.chatCompletions(any()) }.returns(flowOf(chatCompletionChunk))
    }

    @AfterTest
    fun teardown() {
        Dispatchers.resetMain()
    }

    @Test
    fun `Should return weekly summary`() = runTest {
        every { openAI.chatCompletions(any()) }.returns(flowOf(chatCompletionChunk))

        openDiaryAI.getWeeklySummary(emptyList()).test {
            val summary = awaitItem()
            awaitComplete()

            assertThat(summary).isNotEmpty()
        }
    }

    @Test
    fun `Should query diary entries`() = runTest {
        coEvery { openAI.chatCompletion(any()) }.returns(chatCompletion)

        val response = openDiaryAI.queryDiaries(emptyList())
        assertThat(response).isNotEmpty()
    }

    @Test
    fun `Should generate diary entry`() = runTest {
        openDiaryAI.generateDiary("hello", 100).test {
            val generated = awaitItem()
            cancelAndIgnoreRemainingEvents()

            assertThat(generated).isNotEmpty()
        }
    }
}

import org.koin.dsl.module

internal fun screenModules(): Module = module {
    single<Logger> {
        // TODO: Replace with Kermit Logger
        Logger
    }
    singleOf(::DiaryListViewModel)
    singleOf(::CreateDiaryViewModel)
    singleOf(::FavoriteViewModel)

    }

    fun deleteDiary(diary: Diary) = screenModelScope.launch {
        when (val result = deleteDiaryUseCase(listOf(diary))) {
            is Result.Failure -> {
                // TODO: Handle unhappy path gracefully when deleting diary from details
            }

            is Result.Success -> {
                val deletedItems = result.data
                if (deletedItems != 0) {
                    mutableState.update {
                        DetailsScreenState.DiaryDeleted
                    }
                }
            }
        }
    }