Test that AddArtScreen correctly collects text inputs and triggers the save action (which inserts into DB through ViewModel).

We will test three layers of behaviour:

1. Input field typing: verifies that the user can type into text fields.

2. Save button click: triggers the onSaveClick callback.

3. Data propagation: ensures that correct data (name, artist, year, imageUrl) is passed upward.

We’re not testing the Room DB directly — only verifying that the UI correctly sends the event (the ViewModel can handle DB insertion separately with its own unit test). We have already covered test earlier.

@HiltAndroidTest
class AddArtScreenTest {

    @get:Rule
    val composeRule = createComposeRule()

    private var savedArt: Art? = null

    @Test
    fun addArtScreen_userInputAndSaveButton_callsOnSaveClickWithCorrectData() {
        // Given
        composeRule.setContent {
            AddArtScreen(
                imageUrl = "url1",
                onSaveClick = { name, artist, year, imageUrl ->
                    savedArt = Art(
                        name = name,
                        artistName = artist,
                        year = year,
                        imageUrl = imageUrl
                    )
                },
                onNavigateToImageSearch = {},
                onNavigateBack = {},
                uiEventFlow = MutableSharedFlow()
            )
        }

        // When - simulate typing text
        composeRule.onNodeWithText("Enter Name").performTextInput("Mona Lisa")
        composeRule.onNodeWithText("Enter Artist").performTextInput("Da Vinci")
        composeRule.onNodeWithText("Enter Year").performTextInput("1503")

        // And click save
        composeRule.onNodeWithText("Save").performClick()

        // Then - verify the callback got correct values
        composeRule.runOnIdle {
            assertThat(savedArt).isNotNull()
            assertThat(savedArt!!.name).isEqualTo("Mona Lisa")
            assertThat(savedArt!!.artistName).isEqualTo("Da Vinci")
            assertThat(savedArt!!.year).isEqualTo("1503")
            assertThat(savedArt!!.imageUrl).isEqualTo("url1")
        }
    }

    @Test
    fun addArtScreen_clicksImage_navigatesToImageSearch() {
        var navigated = false

        composeRule.setContent {
            AddArtScreen(
                imageUrl = null,
                onSaveClick = { _, _, _, _ -> },
                onNavigateToImageSearch = { navigated = true },
                onNavigateBack = {},
                uiEventFlow = MutableSharedFlow()
            )
        }

        composeRule.onNodeWithContentDescription("Art Image").performClick()
        composeRule.runOnIdle { assertThat(navigated).isTrue() }
    }

    @Test
    fun addArtScreen_showsToastOnShowToastEvent() {
        val sharedFlow = MutableSharedFlow<ArtViewModel.UiEvent>()

        composeRule.setContent {
            AddArtScreen(
                imageUrl = "url1",
                onSaveClick = { _, _, _, _ -> },
                onNavigateToImageSearch = {},
                onNavigateBack = {},
                uiEventFlow = sharedFlow
            )
        }

        composeRule.runOnIdle {
            runBlocking {
                sharedFlow.emit(ArtViewModel.UiEvent.ShowToast("Test message"))
            }
        }
    }
}

@RunWith(AndroidJUnit4::class)
class ArtListScreenTest {

    @get:Rule
    val composableRule = createComposeRule()

    // ---------- Fake Repository ----------
    private val fakeRepo = object : ArtRepositoryInterface {
        override fun getArt(): Flow<List<Art>> = flowOf(
            listOf(
                Art(id = 1, name = "Starry Horse", artistName = "Viru Pandey", year = "1904", imageUrl = "url1"),
                Art(id = 2, name = "Mano ya na mano", artistName = "Satish Shah", year = "1998", imageUrl = "url2")
            )
        )

        override suspend fun insertArt(art: Art) {}
        override suspend fun deleteArt(art: Art) {}
        override fun searchImage(userQuery: String): Flow<Resource<List<ImageResult>>> =
            flow { emit(Resource.Success(emptyList())) }
    }

    private val getArtUseCase = GetArtUseCase(fakeRepo)
    private val searchImageUseCase = SearchImageUseCase(fakeRepo)
    private val insertArtUseCase = InsertArtUseCase(fakeRepo)
    private val deleteArtUseCase = DeleteArtUseCase(fakeRepo)

    private val useCases = ArtUseCases(
        getArtUseCase, searchImageUseCase,
        insertArtUseCase = insertArtUseCase,
        deleteArtUseCase = deleteArtUseCase
    )
    private val viewModel = ArtViewModel(useCases)

    private val fakeArtList = listOf(
        Art(1, "Starry Horse", "Viru Pandey", "1904", "url1"),
        Art(2, "Mano ya na mano", "Satish Shah", "1998", "url2")
    )

    // -------------------------------------------------------------
    // 1. Normal data case — list should show all artworks
    // -------------------------------------------------------------
    @Test
    fun artListScreen_displaysArtNamesFromViewModel() {
        composableRule.setContent {
            ArtListScreen(viewModel)
        }

        composableRule.onNodeWithText("Starry Horse").assertIsDisplayed()
        composableRule.onNodeWithText("Mano ya na mano").assertIsDisplayed()
    }

    // -------------------------------------------------------------
    // 2. Loading state test — CircularProgressIndicator visible
    // -------------------------------------------------------------
    @Test
    fun artListScreen_showsLoadingIndicatorWhenLoading() {
        composableRule.setContent {
            ArtListScreen(viewModel, isLoading = true)
        }

        composableRule.onNodeWithTag("Progress", useUnmergedTree = true).assertExists()
    }

    // -------------------------------------------------------------
    // 3. Error message test
    // -------------------------------------------------------------
    @Test
    fun artListScreen_displaysErrorMessageWhenErrorOccurs() {
        composableRule.setContent {
            ArtListScreen(viewModel, errorMessage = "Something went wrong")
        }

        composableRule.onNodeWithText("Something went wrong").assertIsDisplayed()
    }

    // -------------------------------------------------------------
    // 4. Empty list test — should show "No artworks found!"
    // -------------------------------------------------------------
    @Test
    fun artListScreen_displaysEmptyMessageWhenListIsEmpty() {
        val emptyRepo = object : ArtRepositoryInterface {
            override fun getArt(): Flow<List<Art>> = flowOf(emptyList())
            override suspend fun insertArt(art: Art) {}
            override suspend fun deleteArt(art: Art) {}
            override fun searchImage(userQuery: String): Flow<Resource<List<ImageResult>>> =
                flow { emit(Resource.Success(emptyList())) }
        }

        val emptyViewModel = ArtViewModel(
            ArtUseCases(GetArtUseCase(emptyRepo), SearchImageUseCase(emptyRepo),
                InsertArtUseCase(emptyRepo),
                DeleteArtUseCase(emptyRepo)
            )
        )

        composableRule.setContent {
            ArtListScreen(viewModel = emptyViewModel)
        }

        composableRule.onNodeWithText("No artworks found!").assertIsDisplayed()
    }

    // -------------------------------------------------------------
    // 5. FAB click test — verify callback is triggered
    // -------------------------------------------------------------
    @Test
    fun artListScreen_fabClickTriggersCallback() {
        var clicked = false

        composableRule.setContent {
            ArtListScreen(viewModel, onFabClick = { clicked = true })
        }

        composableRule.onNodeWithContentDescription("Add Art").performClick()
        assertThat(clicked).isTrue()
    }

    // -------------------------------------------------------------
    // 6. Swipe left to delete — confirm dialog and callback trigger
    // -------------------------------------------------------------
    @Test
    fun artListScreen_swipeLeftShowsDeleteDialogAndConfirmsDelete() {
        var deletedArt: Art? = null

        composableRule.setContent {
            ArtListScreen(
                viewModel = viewModel,
                onDeleteClick = { deletedArt = it }
            )
        }

        // Perform a long swipe to the left on the first card
        composableRule.onNodeWithTag("SwipeItem_1")
            .performTouchInput { swipeLeft(startX = 1000f, endX = 0f) }

        // Let Compose process the gesture
        composableRule.waitForIdle()

        // Now the dialog should be visible
        composableRule.onNodeWithText("Delete Artwork").assertIsDisplayed()
        composableRule.onNodeWithText("Delete").performClick()

        assertThat(deletedArt?.name).isEqualTo("Starry Horse")
}

}

• The ViewModel correctly invokes the use cases

• The fake repository’s state updates

• The UI state (like the art list) reflects those changes

/**
 * ## Unit test for [ArtViewModel].
 *
 * Verifies that:
 * 1. [ArtViewModel] correctly collects from both [GetArtUseCase] and [SearchImageUseCase].
 * 2. Data from repository flows into StateFlows (`artList`, `imageList`, `errorMessage`, `isLoading`).
 * 3. Loading and error flags behave as expected for both success and failure.
 */
@OptIn(ExperimentalCoroutinesApi::class)
class ArtViewModelRevisedTest {

    // -------------------------
    // Fake repository (stateful)
    // -------------------------
    class FakeRepository : ArtRepositoryInterface {

        // initial list
        private val _arts = MutableStateFlow(
            listOf(
                Art(id = 1, name = "Starry Horse", artistName = "Viru Pandey", year = "1904", imageUrl = "url1"),
                Art(id = 2, name = "Mano ya na Mano", artistName = "Satish Shah", year = "1998", imageUrl = "url2")
            )
        )
        // expose read-only StateFlow
        val artsState: StateFlow<List<Art>> get() = _arts

        // Return the live flow so collectors observe updates
        override fun getArt(): Flow<List<Art>> = _arts

        // mutate and emit a new list (use setValue or emit)
        override suspend fun insertArt(art: Art) {
            val updated = _arts.value.toMutableList().apply { add(art) }
            _arts.emit(updated)
        }

        override suspend fun deleteArt(art: Art) {
            val updated = _arts.value.toMutableList().apply { remove(art) }
            _arts.emit(updated)
        }

        // simple searchImage implementation for tests
        override fun searchImage(userQuery: String): Flow<Resource<List<ImageResult>>> = flow {
            emit(Resource.Loading())
            val results = listOf(
                ImageResult(id = 1, previewURL = "preview1", largeImageURL = "large1"),
                ImageResult(id = 2, previewURL = "preview2", largeImageURL = "large2")
            )
            emit(Resource.Success(results))
        }
    }

    // -------------------------
    // Test deps
    // -------------------------
    private lateinit var fakeRepo: FakeRepository
    private lateinit var getArtUseCase: GetArtUseCase
    private lateinit var searchImageUseCase: SearchImageUseCase
    private lateinit var insertArtUseCase: InsertArtUseCase
    private lateinit var deleteArtUseCase: DeleteArtUseCase
    private lateinit var artUseCases: ArtUseCases
    private lateinit var viewModel: ArtViewModel

    // a second VM wired to mocked usecases to test search error flows etc.
    private lateinit var mockSearchImageUseCase: SearchImageUseCase
    private lateinit var fakeUseCases: ArtUseCases
    private lateinit var viewModel2: ArtViewModel

    @Before
    fun setup() {
        fakeRepo = FakeRepository()
        getArtUseCase = GetArtUseCase(fakeRepo)
        searchImageUseCase = SearchImageUseCase(fakeRepo)
        insertArtUseCase = InsertArtUseCase(fakeRepo)
        deleteArtUseCase = DeleteArtUseCase(fakeRepo)

        artUseCases = ArtUseCases(
            getArtUseCase = getArtUseCase,
            searchImageUseCase = searchImageUseCase,
            insertArtUseCase = insertArtUseCase,
            deleteArtUseCase = deleteArtUseCase
        )

        // VM wired to the real fakeRepo usecases
        viewModel = ArtViewModel(artUseCases)

        // second VM wired to mocked usecases for search tests
        mockSearchImageUseCase = mock()
        fakeUseCases = mock {
            on { getArtUseCase } doReturn mock()
            on { searchImageUseCase } doReturn mockSearchImageUseCase
            on { insertArtUseCase } doReturn mock()
            on { deleteArtUseCase } doReturn mock()
        }
        viewModel2 = ArtViewModel(fakeUseCases)
    }

    // -------------------------
    // TEST 1 — getArt collected initially
    // -------------------------
    @Test
    fun `artList emits expected fake data after initialization`() = runTest {
        val expected = fakeRepo.artsState.value

        // collect and assert the first emission equals expected
        viewModel.arts.test {
            val emission = awaitItem()
            assertThat(emission).isEqualTo(expected)
            cancelAndIgnoreRemainingEvents()
        }
    }

    // -------------------------
    // TEST 2 — searchImage success flow (via mocked usecase)
    // -------------------------
    @Test
    fun `searchImage emits loading then success updates imageList`() = runTest {
        val fakeResults = listOf(
            ImageResult(previewURL = "preview1", id = 0, largeImageURL = "large1"),
            ImageResult(previewURL = "preview2", id = 2, largeImageURL = "large2")
        )

        whenever(mockSearchImageUseCase.invoke("tigers")).thenReturn(
            flowOf(Resource.Loading(), Resource.Success(fakeResults))
        )

        viewModel2.searchState.test {
            viewModel2.searchImage("tigers")

            awaitItem() // initial state
            val loading = awaitItem()
            assertThat(loading.isLoading).isTrue()

            val success = awaitItem()
            assertThat(success.isLoading).isFalse()
            assertThat(success.searchResults).isEqualTo(fakeResults.map { it.previewURL })
            assertThat(success.errorMessage).isNull()

            cancelAndIgnoreRemainingEvents()
        }
    }

    // -------------------------
    // TEST 3 — searchImage error flow
    // -------------------------
    @Test
    fun `searchImage emits error updates errorMessage`() = runTest {
        whenever(mockSearchImageUseCase.invoke("dogs")).thenReturn(
            flowOf(Resource.Loading(), Resource.Error("Network error"))
        )

        viewModel2.searchState.test {
            viewModel2.searchImage("dogs")

            awaitItem() // initial state
            val loading = awaitItem()
            assertThat(loading.isLoading).isTrue()

            val errorState = awaitItem()
            assertThat(errorState.isLoading).isFalse()
            assertThat(errorState.errorMessage).isEqualTo("Network error")

            cancelAndIgnoreRemainingEvents()
        }
    }

    // -------------------------
    // TEST 4 — initial search state values
    // -------------------------
    @Test
    fun `initial state should be empty and not loading`() = runTest {
        val state = viewModel.searchState.value
        assertFalse(state.isLoading)
        assertNull(state.errorMessage)
        assertTrue(state.searchResults.isEmpty())
    }

    // -------------------------
    // TEST 5 — insert updates list (capture emission after action)
    // -------------------------
    @Test
    fun `insert updates Art List`() = runTest {
        val newArt = Art(id = 12, artistName = "Nah kehta hua", name = "pattar aur kanta", year = "1982", imageUrl = "yaq1")

        // Start collecting BEFORE action so Turbine can capture subsequent emissions
        viewModel.arts.test {
            val first = awaitItem() // initial list

            // act
            viewModel.insertArt(newArt)
            // allow VM/repo coroutines to run
            advanceUntilIdle()

            // the next emission should contain newArt
            val updated = awaitItem()
            assertThat(updated).contains(newArt)

            cancelAndIgnoreRemainingEvents()
        }
    }

    // -------------------------
    // TEST 6 — delete removes art from list
    // -------------------------
    @Test
    fun `deleteArt removes art from list`() = runTest {
        val artToDelete = fakeRepo.artsState.value.first()

        // Start collecting BEFORE action
        viewModel.arts.test {
            val first = awaitItem() // initial emission

            // act
            viewModel.deleteArt(artToDelete)
            advanceTimeBy(100)
            advanceUntilIdle()

            val afterDelete = awaitItem()
            assertThat(afterDelete).doesNotContain(artToDelete)

            cancelAndIgnoreRemainingEvents()
        }
    }
}

Insert Art — Behaviour Verification

Goal → Ensure repository calls artDao.insertArt() with the correct converted entity.

Delete Art — Behaviour Verification

Goal → Ensure repository correctly removes the item through DAO.

/**
 * Tests the ArtRepositoryImpl class to verify that
 * - Data from DAO is correctly mapped to domain model.
 * - The Flow emitted matches the expected data.
 * - The repository interacts correctly with DAO and API layers.
 * - API returns expected Flow<Resource> for searchImage()
 */
class ArtRepositoryImplTest {

    private lateinit var fakeDao: FakeArtDao
    private lateinit var mockApi:ImageApi
    private lateinit var repositoryImpl: ArtRepositoryImpl
    private val dummyApiKey = "FAKE_KEY"

    @Before
    fun setup(){

        fakeDao = FakeArtDao()
        mockApi = mock(ImageApi::class.java)
        repositoryImpl = ArtRepositoryImpl(fakeDao,mockApi,dummyApiKey)
    }

    @Test
    fun `getArt returns mapped domain objects`() = runTest {
        //arrange
        val testArtEntity =
            ArtEntity(name = "jalwa fariq", artistName = "rehman malik", year = "1989", imageUrl = "url2")

        fakeDao.insertArt(testArtEntity)

        val result = repositoryImpl.getArt().first()

        //assert
        assertThat(result.size).isEqualTo(1)
        assertThat(result[0].year).isEqualTo("1989")
        assertThat(result[0].name).isEqualTo("jalwa fariq")
        assertThat(result[0].artistName).isEqualTo("rehman malik")
    }

    // --- Test 2: searchImage returns success ---
    @Test
    fun `searchImage emits loading and success when API returns data`() = runTest {
        // Arrange fake API response
        val fakeImageResults = listOf(
            ImageResultDto(
                id = 1, previewURL = "url1", largeImageURL = "urlLarge",
                comments = 0,
                downloads = 0,
                favorites = 0,
                imageHeight = 111,
                imageSize = 112,
                imageWidth = 111,
                likes = 12,
                pageURL = "TODO()",
                previewHeight = 12,
                previewWidth = 22,
                tags = "TODO()",
                type = "TODO()",
                user = "TODO()",
                userId = 0,
                userImageURL = "TODO()",
                views = 0,
                webformatHeight = 0,
                webformatURL = "TODO()",
                webformatWidth = 11
            )
        )
        val responseDto = ImageResponseDto(total = 1, totalHits = 1, hits = fakeImageResults)

        `when`(mockApi.searchImages(dummyApiKey, "cats")).thenReturn(Response.success(responseDto))

        // Act
        val results = repositoryImpl.searchImage("cats").toList()

        // Assert
        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Success::class.java)
        val success = results[1] as Resource.Success
        assertThat(success.data?.size).isEqualTo(1)
        assertThat(success.data?.get(0)?.previewURL).isEqualTo("url1")
    }

    // --- Test 3: searchImage emits error when API key empty ---
    @Test
    fun `searchImage emits error when api key empty`() = runTest {
        val repo = ArtRepositoryImpl(fakeDao, mockApi, apiKey = "")

        val results = repo.searchImage("cats").toList()

        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Error::class.java)
        assertThat(results[1].message).isEqualTo("Empty api key")
    }

    // --- Test 4: searchImage emits error when API fails ---
    @Test
    fun `searchImage emits error when API returns failure`() = runTest {
        val errorResponse = Response.error<ImageResponseDto>(
            404,
            ResponseBody.create("application/json".toMediaTypeOrNull(), "Not Found")
        )

        `when`(mockApi.searchImages(dummyApiKey, "dogs")).thenReturn(errorResponse)

        val results = repositoryImpl.searchImage("dogs").toList()

        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Error::class.java)
        assertThat(results[1].message).contains("API error")
    }

    //test 5: Ensure repository calls artDao.insertArt() with the correct converted entity.
    @Test
    fun `insertArt calls dao insert with correct data`() =runTest {

        //arrange
        val art = Art(name = "Maddy King", artistName = "Kimshi Yako",id=4, year = "1987", imageUrl = "url2")

        //act
        repositoryImpl.insertArt(art)

        //assert
        val allArts = fakeDao.getAllArts().first()
        assertThat(allArts.size).isEqualTo(1)
        assertThat(allArts[0].name).isEqualTo("Maddy King")
        assertThat(allArts[0].artistName).isEqualTo("Kimshi Yako")
        assertThat(allArts[0].year).isEqualTo("1987")

       // This checks whether the domain object is mapped and persisted correctly.
    }

    //Test 6: Ensure repository correctly removes the item through DAO.
    @Test
    fun `deleteArt removes item from dao`() = runTest{

        //arrange : add an art first
        val art = ArtEntity(id = 3, name = "Kashi Mora", artistName = "Kami Dhingra", year = "1932", imageUrl = "uri1")

        fakeDao.insertArt(art)

        //act
        repositoryImpl.deleteArt(art.toDomainModel())

        //assert
        val allArts = fakeDao.getAllArts().first()
        assertThat(allArts).doesNotContain(art)

    }
}

/*
A Fake is a lightweight, in-memory implementation of the real ArtDao interface.
FakeArtDao mimics the behavior of the Room DAO but uses plain Kotlin collections and Flows instead of a real database.
It's designed for fast, deterministic tests of higher layers (repository, use cases, ViewModel) without using Room or an emulator.
Fake has real behavior (stores and returns data) so it's ideal for validating interactions and data flow.
*/

/*
Responsibilities (what FakeArtDao must do)
Implement the ArtDao interface exactly (same function signatures).
Expose a Flow<List<ArtEntity>> for getAllArts() that behaves like Room: emits the current list and emits new lists when data changes.
Provide working insertArt() and deleteArt() semantics (mutate internal state).
Be deterministic and resettable between tests.
Be coroutine-friendly (suspend functions behave like the real DAO).
 */
class FakeArtDao : ArtDao {
    private val data = mutableListOf<ArtEntity>()

    override fun getAllArts(): Flow<List<ArtEntity>> = flowOf(data)

    override suspend fun insertArt(artEntity: ArtEntity) {
        data.add(artEntity)
    }

    override suspend fun deleteArt(artEntity: ArtEntity) {
        data.remove(artEntity)
    }
}

The Repository implementation class has all six tests as elucidated above.

Let’s write clear, minimal, and clean unit tests using JUnit + Kotlin coroutines test.

We'll create a test class, e.g.
InsertArtUseCaseTest.kt and DeleteArtUseCaseTest.kt.

Each test will:

1. Use a fake repository that implements ArtRepositoryInterface.

2. Call the use case.

3. Assert on the returned Resource or expected behaviour.

class InsertArtUseCaseTest {

    private lateinit var fakeRepository: FakeArtRepository
    private lateinit var insertArtUseCase: InsertArtUseCase

    @Before
    fun setup() {
        fakeRepository = FakeArtRepository()
        insertArtUseCase = InsertArtUseCase(fakeRepository)
    }

    @Test
    fun `insert art with valid data returns success`() = runTest {
        val art = Art(
            name = "Mona Lisa",
            artistName = "Da Vinci",
            year = "1503",
            imageUrl = "https://example.com/mona.jpg"
        )

        val result = insertArtUseCase(art)


       Truth.assertThat(result.data).isNotNull()
       Truth.assertThat(result).isInstanceOf(Resource.Success::class.java)
       Truth.assertThat(result.data?.year).isEqualTo("1503")

    }

    @Test
    fun `insert art with blank fields returns error`() = runTest {
        val invalidArt = Art(
            name = "",
            artistName = "Artist",
            year = "2000",
            imageUrl = ""
        )

        val result = insertArtUseCase(invalidArt)

        Truth.assertThat(result).isInstanceOf(Resource.Error::class.java)
        Truth.assertThat(result.data).isNull()
        Truth.assertThat(fakeRepository.insertedArts).isEmpty()
        Truth.assertThat(result.message).isEqualTo("Fields must not be empty and/or filled incorrectly")
    }
}

InsertArtUseCase correctly validates input before inserting. It calls the repository only for valid data.

DeleteArtUseCase safely removes items. Both use cases handle coroutines properly.

SUMMARY

NOTES

This screen displays a scrollable list of artworks fetched from the database via the ArtViewModel.

It supports:

• Viewing all saved artworks.

• Adding a new artwork via FloatingActionButton (FAB).

• Deleting artworks with swipe + confirmation dialog.

• Handling loading and error states gracefully.

DIAGRAM

graph TD
    A[ArtListScreen] -->|FAB Click| B[AddArtScreen]
    A -->|Swipe Left| C[AlertDialog]
    C -->|Confirm Delete| D[ViewModel.deleteArt]
    D -->|Updates DB| E[StateFlow emits new list]
    E -->|Recomposition| A

IMPORTANT POINTS

• This screen allows users to:

  • Enter details of an artwork (name, artist, year)

  • Pick an image (from another screen)

  • Save the artwork

It connects the UI layer with the ViewModel, following Clean Architecture principles — the UI collects input, while business logic stays in the ViewModel.

• AddArtScreen - This is a UI function that describes what to display and how it should react to state changes. It receives callbacks like onSaveClick, onNavigateBack, etc.→ This keeps the screen stateless and reusable.

graph LR
    UI[AddArtScreen] -->|User input| VM[ArtViewModel]
    VM -->|uiEvent : SharedFlow| UI
    UI -->|onNavigateToImageSearch| Search[ImageSearchScreen]
    Search -->|Selected Image URL| UI

• The UI is reactive: it updates based on StateFlow/SharedFlow from ViewModel.

• Navigation and UI state are controlled indirectly via events and callbacks (no direct coupling).

IMPORTANT POINTS

1. The AppNavGraph function defines all the navigation routes in the app — it connects the three main screens:

   • Art List → displays saved artworks.

   • Art Details → lets users add or edit an artwork.

   • Image Search → lets users find an image using the Pixabay API.

2. The navigation graph uses a root route called "root_graph". The key idea is to share the same ArtViewModel across all these screens.
   This acts like a common parent container for all the child screens. That means any state (like the selected image, search results, or form data) remains the same when we navigate between them.

3. Normally, every screen would get its own instance of a ViewModel when using hiltViewModel().
   But in this setup, we use:

    val parentEntry = remember(backStackEntry) {
        navController.getBackStackEntry("root_graph")
    }
    val viewModel: ArtViewModel = hiltViewModel(parentEntry)
   

   This makes sure the same ViewModel instance is reused for every screen inside the "root_graph".

4. Because of this shared scope:

   • When we set an image URL in the ImageSearch screen, it’s still available in the ArtDetails screen after going back.

   • When we delete or insert an artwork, the ArtList screen automatically updates because the same ViewModel holds the data.

5. Each composable (screen) collects StateFlow values from the ViewModel using collectAsState().

   This lets the UI update automatically when the ViewModel state changes.

6. For cleanup:

   • When we navigate back from Image Search → we call viewModel.clearImageResults().

   • When we go back from Art Details → we call viewModel.clearSelectedImageUrl().
     This ensures no leftover data appears when the user reopens those screens.

7. The UiEvent system (inside the ViewModel) helps trigger navigation or toast messages based on ViewModel logic — separating UI concerns from the business logic layer.

8. This setup follows Clean Architecture principles:

   • ViewModel holds logic and state.

   • Composables just display data and forward user actions.

   • Navigation and UI events are handled reactively.

DIAGRAM : Navigation + Shared View Model

graph TD

    subgraph RootGraph["root_graph(Shared ViewModel Scope)"]
        A[ArtListScreen]
        B[ArtDetailsScreen]
        C[ImageSearchScreen]
    end

    A -->|FAB Click| B
    B -->|Open Image Search| C
    C -->|Select Image| B
    B -->|Save Art| A

    subgraph VM["ArtViewModel (shared)"]
        V1[arts : StateFlow<List<Art>>]
        V2[selectedImageUrl : StateFlow<String?>]
        V3[searchResults : StateFlow<Resource<List<ImageResult>>>]
        V4[addArtState : StateFlow<AddArtUiState>]
        V5[uiEvent : SharedFlow<UiEvent>]
    end

    A -->|Observes| VM
    B -->|Observes| VM
    C -->|Observes| VM

    VM -->|Updates State| A
    VM -->|Updates State| B
    VM -->|Updates State| C

SUMMARY

• root_graph is the shared parent that defines the scope of the shared ArtViewModel.

• Each screen uses hiltViewModel(parentEntry) to access the same instance.

• StateFlows keep the UI reactive and consistent.

• Manual clearing methods prevent old data from leaking between sessions.

• The ViewModel acts as a single source of truth for the entire feature (Art Management + Image Search).

    /**
     * Inserts a new artwork into the local database.
     *
     * @param art The [Art] object containing artwork details (name, artist, year, image).
     *
     * This method calls the [InsertArtUseCase] and, upon success, reloads the updated art list.
     * If an error occurs, it updates the state with an error message.
     *
     * Internal helper to collect artworks and update the UI state.
     * Called during initialization and after insert/delete operations.
     * It continuously listens for changes from the Room database.
     */

    fun insertArt(art: Art) {
        //Log.d("baxss", art.toString())

        if (art.name.isBlank() || art.artistName.isBlank() || art.year.isBlank() || art.imageUrl.isBlank()) {
            sendUiEvent("All fields are required")
            return
        }

        viewModelScope.launch {
            _addState.update { it.copy(isLoading = true) }

            when (val result = useCases.insertArtUseCase(art)) {
                is Resource.Error -> {
                    _addState.update { it.copy(isLoading = false) }
                    sendUiEvent(result.message ?: "Something went wrong")
                }

                is Resource.Success -> {
                    _addState.update { it.copy(isLoading = false, success = true) }
                    sendUiEvent("Art saved successfully!")
                    loadArts()
                }

                else -> Unit
            }
        }
    }

    private val _uiEvent = MutableSharedFlow<UiEvent>()
    val uiEvent = _uiEvent.asSharedFlow()

    private fun sendUiEvent(message: String) {
        viewModelScope.launch {
            _uiEvent.emit(UiEvent.ShowToast(message))
        }
    }

    sealed class UiEvent {
        data class ShowToast(val message: String) : UiEvent()
    }


    /**
     * Deletes an existing artwork from the local database.
     *
     * @param art The [Art] object representing the artwork to be deleted.
     *
     * This function delegates the deletion logic to the [DeleteArtUseCase].
     * It does not emit UI state changes but can be extended for confirmation handling.
     */

    fun deleteArt(art: Art) {
        viewModelScope.launch {
            useCases.deleteArtUseCase(art)
        }
    }

The left swipe of the list item in the ArtListScreen triggers a call to the deletion function.

The Save button click verifies whether all image details are available. If yes, then the Art data is saved inside the Room DB by triggering the insert function. If the Art data is incomplete, then we display the toast message asking the user to modify.

@Singleton
class ArtRepositoryImpl @Inject constructor(private val artDao: ArtDao,
                                            private val imageApi:ImageApi,
                                            @Named("apiKey") private val apiKey: String):ArtRepositoryInterface {
    override fun getArt(): Flow<List<Art>> {

        //returns a stream (Flow) that emits a list of ArtEntity objects every time the ROOM DB table changes.
        val artStream = artDao.getAllArts()

       val artObjs = artStream.map { entityList -> entityList.map { it.toDomainModel() } }
        return artObjs
    }

    override suspend fun insertArt(art: Art) {
         artDao.insertArt(art.toEntity())
    }

    override suspend fun deleteArt(art: Art) {
         artDao.insertArt(art.toEntity())
    }

    override fun searchImage(imageString: String): Flow<Resource<List<ImageResult>>> = flow {
        emit(Resource.loading())
        //Log.d("PixabayRepo", "query code: ${imageString}")

        if(apiKey.isEmpty()){
            emit(Resource.error("Empty api key"))
            //Log.d("PixabayRepo", "emptiness")
            return@flow
        }

        try {
            val response = imageApi.searchImages(apiKey, imageString)
            //Log.d("PixabayRepo", "Response code: ${response.code()}, success=${response.isSuccessful}")

            if (response.isSuccessful) {
                val body = response.body()

                if (body != null) {
                    // Map the list of DTOs to domain models
                    val results = body.hits.map {it.toDomainModel()}
                    //Log.d("PixabayRepo", "Received ${body.hits.size} images for query=$imageString")

                    emit(Resource.success(results))
                } else {
                    emit(Resource.error("Empty response body"))
                   // Log.d("error pixa","error")
                }
            } else {
                emit(Resource.error("API error: ${response.message()}"))
                //Log.d("error API", response.message())
            }

        } catch (e: Exception) {
            emit(Resource.error("Network error: ${e.message}"))
            //e.message?.let { Log.d("error API", it) }
        }
    }
}

The artDao object inserts or deletes an Art object in the Room DB.

data class ArtUseCases(
   val getArtUseCase: GetArtUseCase,
    val searchImageUseCase: SearchImageUseCase,
    val insertArtUseCase: InsertArtUseCase,
    val deleteArtUseCase:DeleteArtUseCase
)

We will now code the two classes for insert and delete usecases. The code is easy to understand.

class InsertArtUseCase(private val artRepository: ArtRepositoryInterface) {

    suspend operator fun invoke(art: Art): Resource<Art> {
        // Basic validation
        if (art.name.isBlank() || art.artistName.isBlank() || art.imageUrl.isBlank() || art.year.isBlank()) {
            return Resource.error("Fields must not be empty and/or filled incorrectly", null)
        }

        // Save to DB through the repository interface
        artRepository.insertArt(art)

        // Return success
        return Resource.success(art)
    }

}

//Purpose: Validate and save a new artwork to the Room DB.
//Domain logic: Ensure fields are valid before inserting.

class DeleteArtUseCase(private val artRep: ArtRepositoryInterface) {

    suspend operator fun invoke(art: Art){
        artRep.deleteArt(art)
    }
}

Now we will code the data layer for the above two usecases - the repository implementation class.

• Emits Loading, Success, and Error states in sequence.

• Interacts properly with the repository’s searchImage() flow.

• Handles both success and failure paths gracefully.

Testing SearchImageUseCase with a Mock Repository

**
 * ## SearchImageUseCaseTest
 *
 * This test verifies that [SearchImageUseCase] correctly reacts to
 * repository emissions. It does **not** hit the real API — instead,
 * the repository is **mocked** using Mockito.
 *
 * ### Test Scope
 * - Domain Layer only
 * - No Retrofit or Room
 * - No Android framework dependencies
 *
 * ### What We’re Testing
 * 1. The flow of Resource states (Loading → Success / Error)
 * 2. That the use case correctly calls the repository method
 */
@OptIn(ExperimentalCoroutinesApi::class)
class SearchImageUseCaseTest {

    /**
     * Mocked repository so that we don’t call the actual implementation.
     *
     * Mockito will intercept any calls like `repository.searchImage("cats")`
     * and return whatever fake Flow we configure it to emit.
     */
    @Mock
    private lateinit var repository:ArtRepositoryInterface

    /**
     * The UseCase we’re testing, instantiated with the mocked repository.
     */
    private lateinit var searchImageUseCase: SearchImageUseCase

    /**
     * ### @Before
     * Called before each test.
     *
     * 1. Initializes the `@Mock` fields (so that Mockito can inject fake objects).
     * 2. Instantiates the UseCase with the mock repository.
     */
    @Before
    fun setup(){
        MockitoAnnotations.openMocks(this)
        searchImageUseCase = SearchImageUseCase(repository)
    }

    /**
     * ## Test 1: Success Case
     *
     * Simulates a successful API call returning a list of images.
     *
     * Flow emission pattern:
     * 
     * LOADING → SUCCESS
     * 
     */
    @Test
    fun `should emit loading and success when repository returns data`() = runTest {
        // Arrange: Create fake image data
        val mockImages = listOf(
            ImageResult(id = 1, previewURL = "url1", largeImageURL = "urlLarge")
        )

        // Mock repository to emit loading → success sequence
        `when`(repository.searchImage("cats")).thenReturn(
            flow {
                emit(Resource.loading())
                emit(Resource.success(mockImages))
            }
        )

        // Act: Execute the use case
        val results = searchImageUseCase("cats").toList()

        // Assert: Verify the flow emits Loading then Success
        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Success::class.java)

        val success = results[1] as Resource.Success
        assertThat(success.data).isNotNull()
        assertThat(success.data!!.size).isEqualTo(1)

        // Verify the repository was called correctly
        verify(repository).searchImage("cats")
    }


    /**
     * ## Test 2: Error Case
     *
     * Simulates an API/network error scenario.
     *
     * Flow emission pattern:
     * 
     * LOADING → ERROR
     * 
     */

    @Test
    fun `should emit loading and error when repository returns error`() = runTest {
        // Arrange
        val errorMsg = "Network error"

        // Mock repository to emit loading → error sequence
        `when`(repository.searchImage("dogs")).thenReturn(
            flow {
                emit(Resource.loading())
                emit(Resource.error(errorMsg))
            }
        )

        // Act
        val results = searchImageUseCase("dogs").toList()

        // Assert
        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Error::class.java)
        assertThat(results[1].message).isEqualTo(errorMsg)

        verify(repository).searchImage("dogs")
    }

}

/**
Test that SearchImageUseCase correctly:
-----------------------------------------

Emits Loading, Success, and Error states in sequence.
Interacts properly with the repository’s searchImage() flow.
Handles both success and failure paths gracefully.
 * */

/**
 * Tests the ArtRepositoryImpl class to verify that
 * - Data from DAO is correctly mapped to domain model.
 * - The Flow emitted matches the expected data.
 * - The repository interacts correctly with DAO and API layers.
 * - API returns expected Flow<Resource> for searchImage()
 */
class ArtRepositoryImplTest {

    private lateinit var fakeDao: FakeArtDao
    private lateinit var mockApi:ImageApi
    private lateinit var repositoryImpl: ArtRepositoryImpl
    private val dummyApiKey = "FAKE_KEY"

    @Before
    fun setup(){

        fakeDao = FakeArtDao()
        mockApi = mock(ImageApi::class.java)
        repositoryImpl = ArtRepositoryImpl(fakeDao,mockApi,dummyApiKey)
    }

    @Test
    fun `getArt returns mapped domain objects`() = runTest {
        //arrange
        val testArtEntity =
            ArtEntity(name = "jalwa fariq", artistName = "rehman malik", year = "1989", imageUrl = "url2")

        fakeDao.insertArt(testArtEntity)

        val result = repositoryImpl.getArt().first()

        //assert
        assertThat(result.size).isEqualTo(1)
        assertThat(result[0].year).isEqualTo("1989")
        assertThat(result[0].name).isEqualTo("jalwa fariq")
        assertThat(result[0].artistName).isEqualTo("rehman malik")
    }

    // --- Test 2: searchImage returns success ---
    @Test
    fun `searchImage emits loading and success when API returns data`() = runTest {
        // Arrange fake API response
        val fakeImageResults = listOf(
            ImageResultDto(
                id = 1, previewURL = "url1", largeImageURL = "urlLarge",
                comments = 0,
                downloads = 0,
                favorites = 0,
                imageHeight = 111,
                imageSize = 112,
                imageWidth = 111,
                likes = 12,
                pageURL = "TODO()",
                previewHeight = 12,
                previewWidth = 22,
                tags = "TODO()",
                type = "TODO()",
                user = "TODO()",
                userId = 0,
                userImageURL = "TODO()",
                views = 0,
                webformatHeight = 0,
                webformatURL = "TODO()",
                webformatWidth = 11
            )
        )
        val responseDto = ImageResponseDto(total = 1, totalHits = 1, hits = fakeImageResults)

        `when`(mockApi.searchImages(dummyApiKey, "cats")).thenReturn(Response.success(responseDto))

        // Act
        val results = repositoryImpl.searchImage("cats").toList()

        // Assert
        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Success::class.java)
        val success = results[1] as Resource.Success
        assertThat(success.data?.size).isEqualTo(1)
        assertThat(success.data?.get(0)?.previewURL).isEqualTo("url1")
    }

    // --- Test 3: searchImage emits error when API key empty ---
    @Test
    fun `searchImage emits error when api key empty`() = runTest {
        val repo = ArtRepositoryImpl(fakeDao, mockApi, apiKey = "")

        val results = repo.searchImage("cats").toList()

        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Error::class.java)
        assertThat(results[1].message).isEqualTo("Empty api key")
    }

    // --- Test 4: searchImage emits error when API fails ---
    @Test
    fun `searchImage emits error when API returns failure`() = runTest {
        val errorResponse = Response.error<ImageResponseDto>(
            404,
            ResponseBody.create("application/json".toMediaTypeOrNull(), "Not Found")
        )

        `when`(mockApi.searchImages(dummyApiKey, "dogs")).thenReturn(errorResponse)

        val results = repositoryImpl.searchImage("dogs").toList()

        assertThat(results[0]).isInstanceOf(Resource.Loading::class.java)
        assertThat(results[1]).isInstanceOf(Resource.Error::class.java)
        assertThat(results[1].message).contains("API error")
    }
}

/*
A Fake is a lightweight, in-memory implementation of the real ArtDao interface.
FakeArtDao mimics the behavior of the Room DAO but uses plain Kotlin collections and Flows instead of a real database.
It's designed for fast, deterministic tests of higher layers (repository, use cases, ViewModel) without using Room or an emulator.
Fake has real behavior (stores and returns data) so it's ideal for validating interactions and data flow.
*/

/*
Responsibilities (what FakeArtDao must do)
Implement the ArtDao interface exactly (same function signatures).
Expose a Flow<List<ArtEntity>> for getAllArts() that behaves like Room: emits the current list and emits new lists when data changes.
Provide working insertArt() and deleteArt() semantics (mutate internal state).
Be deterministic and resettable between tests.
Be coroutine-friendly (suspend functions behave like the real DAO).
 */
class FakeArtDao : ArtDao {
    private val data = mutableListOf<ArtEntity>()

    override fun getAllArts(): Flow<List<ArtEntity>> = flowOf(data)

    override suspend fun insertArt(artEntity: ArtEntity) {
        data.add(artEntity)
    }

    override suspend fun deleteArt(artEntity: ArtEntity) {
        data.remove(artEntity)
    }
}

/**
 * ## Unit test for [ArtViewModel].
 *
 * Verifies that:
 * 1. [ArtViewModel] correctly collects from both [GetArtUseCase] and [SearchImageUseCase].
 * 2. Data from repository flows into StateFlows (`artList`, `imageList`, `errorMessage`, `isLoading`).
 * 3. Loading and error flags behave as expected for both success and failure.
 */
@OptIn(ExperimentalCoroutinesApi::class)
class ArtViewModelRevisedTest {
    /**
     * A fake repository that simulates both local DB and remote API behavior.
     */
    class FakeRepository : ArtRepositoryInterface {

        val fakeArtList = listOf(
            Art(id = 1, name = "Starry Horse", artistName = "Viru Pandey", year = "1904", imageUrl = "url1"),
            Art(id = 2, name = "Mano ya na Mano", artistName = "Satish Shah", year = "1998", imageUrl = "url2")
        )

        var shouldThrowError = false
        var shouldReturnEmptySearch = false

        override fun getArt(): Flow<List<Art>> {
            return flowOf(fakeArtList)
        }

        override fun insertArt(art: Art) {
            // No-op
        }

        override fun deleteArt(art: Art) {
            // No-op
        }

        override fun searchImage(userQuery: String): Flow<Resource<List<ImageResult>>> {
            return if (shouldThrowError) {
                flow {
                    emit(Resource.Loading())
                    emit(Resource.Error("Network error"))
                }
            } else if (shouldReturnEmptySearch) {
                flow {
                    emit(Resource.Loading())
                    emit(Resource.Success(emptyList()))
                }
            } else {
                val results = listOf(
                    ImageResult(id = 1, previewURL = "preview1", largeImageURL = "large1"),
                    ImageResult(id = 2, previewURL = "preview2", largeImageURL = "large2")
                )
                flow {
                    emit(Resource.Loading())
                    emit(Resource.Success(results))
                }
            }
        }
    }

    private lateinit var fakeRepo: FakeRepository
    private lateinit var getArtUseCase: GetArtUseCase
    private lateinit var searchImageUseCase: SearchImageUseCase
    private lateinit var viewModel: ArtViewModel
    private lateinit var viewModel2: ArtViewModel

    private lateinit var artUseCases:ArtUseCases

    private lateinit var mockSearchImageUseCase: SearchImageUseCase
    private lateinit var fakeUseCases: ArtUseCases

    @Before
    fun setup() {
        fakeRepo = FakeRepository()
        getArtUseCase = GetArtUseCase(fakeRepo)
        searchImageUseCase = SearchImageUseCase(fakeRepo)
        artUseCases = ArtUseCases(getArtUseCase, searchImageUseCase)
        viewModel = ArtViewModel(artUseCases)

        mockSearchImageUseCase = mock()
        fakeUseCases = mock {
            on { searchImageUseCase } doReturn mockSearchImageUseCase
            on { getArtUseCase } doReturn mock() // not used here
        }

        viewModel2 = ArtViewModel(fakeUseCases)
    }

    // --------------------------------------------------------------
    // TEST 1 — LOCAL ART LIST FLOW
    // --------------------------------------------------------------

    @Test
    fun `artList emits expected fake data after initialization`() = runTest {
        val expected = fakeRepo.fakeArtList

        viewModel.arts.test {
            val firstEmission = awaitItem()
            // First emission might be empty before collect
            if (firstEmission.isNotEmpty()) {
                assertThat(firstEmission).isEqualTo(expected)
            } else {
                val next = awaitItem()
                assertThat(next).isEqualTo(expected)
            }
            cancelAndIgnoreRemainingEvents()
        }
    }

    // --------------------------------------------------------------
    // TEST 2 — SEARCH IMAGE SUCCESS
    // --------------------------------------------------------------

    @Test
    fun `searchImage emits loading then success updates imageList`() = runTest {


        // Arrange
        val fakeResults = listOf(
            ImageResult(
                previewURL = "preview1",
                id = 0,
                largeImageURL = "TODO()"
            ),
            ImageResult(previewURL = "preview2",id=2, largeImageURL = "uij")
        )

        // Fake use case flow emitting Loading then Success
        whenever(mockSearchImageUseCase.invoke("tigers")).thenReturn(
            flowOf (
                Resource.Loading(),
                Resource.Success(fakeResults)
            )
        )

        //collect emissions from ViewModel.searchState
        viewModel.searchState.test {
            viewModel.searchImage("tigers")

            //1. first emission : initial state
            awaitItem() //initial {isLoading = false}

            //2. loading state
            val loading = awaitItem()
            assertThat(loading.isLoading).isTrue()

            //success state
            val success = awaitItem()
            assertThat(success.isLoading).isFalse()
            assertThat(success.searchResults).isEqualTo(fakeResults.map{it.previewURL})
            assertThat(success.errorMessage).isNull()

            cancelAndIgnoreRemainingEvents()

        }
    }


    // --------------------------------------------------------------
    // TEST 3 — SEARCH IMAGE ERROR
    // --------------------------------------------------------------

    @Test
    fun `searchImage emits error updates errorMessage`() = runTest {

    }

    // --------------------------------------------------------------
    // TEST 4 — INITIAL STATES
    // --------------------------------------------------------------

    fun `initial state should be empty and not loading`() = runTest {
        // Use either one — both should behave the same initially
        val state = viewModel.searchState.value

        // 1) Check the Search UI state
        assertFalse(state.isLoading)
        assertNull(state.errorMessage)
        assertTrue(state.searchResults.isEmpty())

        // 2) Check general states from ViewModel
        assertTrue(viewModel.arts.value.isEmpty())
        assertTrue(viewModel.searchResults.value.data?.isEmpty() == true)
        assertFalse(viewModel.isLoading.value)
        assertNull(viewModel.errorMessage.value)
    }
}

/**
 * ## ImageSearchScreenTest
 *
 * UI-level tests for [ImageSearchScreen].
 *
 * These tests verify:
 * - UI reacts correctly to state (`isLoading`, `images`)
 * - User interactions trigger expected callbacks
 * - Proper UI components are shown or hidden
 *
 * Uses Jetpack Compose testing framework.
 */
@RunWith(AndroidJUnit4::class)
class ImageSearchScreenTest {

    @get:Rule
    val composeTestRule = createComposeRule()

    /**
     * Test 1: Verify that the basic components
     * (text field + search icon) are displayed initially.
     */

    @Test
    fun initialScreen_displaysSearchFieldAndButton() {
        composeTestRule.setContent {
            ImageSearchScreen(
                isLoading = false,
                images = emptyList(),
                onSearch = {},
                onImageClick = {}
            )
        }

        composeTestRule.onNodeWithText("Search Image").assertIsDisplayed()
        composeTestRule.onNodeWithContentDescription("Search").assertIsDisplayed()
    }


    /**
     * Test 2: When `isLoading` is true, the loading indicator
     * should be visible and no images should be rendered.
     */
    @Test
    fun whenLoading_showsCircularProgressIndicator() {
        composeTestRule.setContent {
            ImageSearchScreen(
                isLoading = true,
                images = emptyList(),
                onSearch = {},
                onImageClick = {}
            )
        }

        composeTestRule.onNode(isDialog()).assertDoesNotExist() // sanity
        composeTestRule.onNode(isRoot()).printToLog("DEBUG")
        composeTestRule.onNode(hasTestTag("ProgressIndicator")).assertDoesNotExist()
        composeTestRule.onNode(hasTestTag("ImageGrid")).assertDoesNotExist()

        // You can optionally tag CircularProgressIndicator
        // in your composable if you want more robust test hooks.
    }

    /**
     * Test 3: When there are images, they appear in the LazyVerticalGrid.
     */
    @Test
    fun whenImagesAvailable_displaysGridItems() {
        val fakeImages = listOf("url1", "url2", "url3")

        composeTestRule.setContent {
            ImageSearchScreen(
                isLoading = false,
                images = fakeImages,
                onSearch = {},
                onImageClick = {}
            )
        }

        // Assert that multiple images are displayed
        fakeImages.forEach { _ ->
            composeTestRule.onAllNodes(hasContentDescription("Search result image"))
                .assertCountEquals(fakeImages.size)
        }
    }


    /**
     * Test 4: Verify search callback is triggered when user enters valid query
     * and taps search icon.
     */
    @Test
    fun enteringValidQuery_triggersOnSearchCallback() {
        var searchTriggered = false
        var queryReceived: String? = null

        composeTestRule.setContent {
            ImageSearchScreen(
                isLoading = false,
                images = emptyList(),
                onSearch = {
                    searchTriggered = true
                    queryReceived = it
                },
                onImageClick = {}
            )
        }

        // Type a valid query
        composeTestRule.onNodeWithText("Search Image").performTextInput("mountain")

        // Tap search icon
        composeTestRule.onNodeWithContentDescription("Search").performClick()

        // Assert callback invoked
        assert(searchTriggered)
        assert(queryReceived == "mountain")
    }

    /**
     * Test 5: Invalid query (<3 characters) does not trigger search callback.
     */
    @Test
    fun enteringShortQuery_doesNotTriggerSearch() {
        var searchTriggered = false

        composeTestRule.setContent {
            ImageSearchScreen(
                isLoading = false,
                images = emptyList(),
                onSearch = { searchTriggered = true },
                onImageClick = {}
            )
        }

        // Type invalid short query
        composeTestRule.onNodeWithText("Search Image").performTextInput("ab")

        // Click the search icon
        composeTestRule.onNodeWithContentDescription("Search").performClick()

        // Callback should not be triggered
        assert(!searchTriggered)
    }

    /**
     * Test 6: Verify that clicking an image triggers `onImageClick` with correct URL.
     */
    @Test
    fun clickingImage_triggersImageClickCallback() {
        val fakeImages = listOf("url1", "url2")
        var clickedUrl: String? = null

        composeTestRule.setContent {
            ImageSearchScreen(
                isLoading = false,
                images = fakeImages,
                onSearch = {},
                onImageClick = { clickedUrl = it }
            )
        }

        // Simulate image click
        composeTestRule.onAllNodes(hasContentDescription("Search result image"))
            .onFirst()
            .performClick()

        assert(clickedUrl == "url1")
    }
}

@Composable
fun ImageSearchScreen(
    isLoading: Boolean,
    images: List<String>,
    onSearch: (String) -> Unit,
    onImageClick: (String) -> Unit
) {
    var query by remember { mutableStateOf("") }
    val context = LocalContext.current
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        OutlinedTextField(
            value = query,
            onValueChange = { query = it },
            label = { Text("Search Image") },
            modifier = Modifier.fillMaxWidth(),
            trailingIcon = {
                IconButton(
                    onClick = {  val trimmedQuery = query.trim()
                        if (trimmedQuery.length < 3) {
                            Toast.makeText( context, "Please enter at least 3 characters", Toast.LENGTH_SHORT).show()
                        } else {
                            onSearch(trimmedQuery)
                        } },
                    enabled = query.isNotBlank()
                ) {
                    Icon(Icons.Default.Search, contentDescription = "Search")
                }
            }
        )

        Spacer(modifier = Modifier.height(16.dp))

        if (isLoading) {
            Box(
                modifier = Modifier.fillMaxSize(),
                contentAlignment = Alignment.Center
            ) {
                CircularProgressIndicator()
            }
        } else {
            LazyVerticalGrid(
                columns = GridCells.Fixed(2),
                modifier = Modifier.fillMaxSize(),
                contentPadding = PaddingValues(8.dp)
            ) {
                items(images) { url ->
                    ImageItem(url = url, onClick = { onImageClick(url) })
                }
            }
        }
    }
}

@Composable
fun ImageItem(url: String?, onClick: () -> Unit) {
    Card(
        modifier = Modifier
            .padding(8.dp)
            .fillMaxWidth()
            .clickable { onClick() },
        elevation = CardDefaults.cardElevation(4.dp)
    ) {
        Image(
            painter = rememberAsyncImagePainter(
                model = url.takeIf { !it.isNullOrEmpty() } ?: R.drawable.ic_launcher_background
            ),
            contentDescription = "Search result image",
            contentScale = ContentScale.Crop,
            modifier = Modifier
                .height(150.dp)
                .fillMaxWidth()
        )
    }
}

We populate the MainActivity directly with the ImageSearchScreen to check whether everything is okay.

@AndroidEntryPoint
class MainActivity : ComponentActivity() {

    private val viewModel: ArtViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
//        setContent {
//            val viewModel: ArtViewModel = hiltViewModel()
//            ArtListScreen(viewModel)
//        }

        setContent {
            ArtLearnersAppTheme {
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    // Collect UI states from the ViewModel
                    val searchState by viewModel.searchState.collectAsState()
                    val results = searchState.searchResults
                    val loading = searchState.isLoading
                    ImageSearchScreen(
                        isLoading = loading,
                        images = searchState.searchResults,  // this is already List<String>
                        onSearch = { query ->
                            viewModel.searchImage(query)
                        },
                        onImageClick = { selectedUrl ->
                            // Handle selected image click (navigate to another screen)
                        }
                    )
                }
            }
        }
    }
}

Run the code on an android device. In the search Input field, try various queries like “rain”, “lion” etc.

We are focused on the searchImage function this for the SearchImageUseCase.

The SearchImageUseCase delegates the API call for search query to the Repository. It wraps the API response into Resource. SearchImageUiState has three possible states Error,Success and Loading. If the API succeeds to fetch the Images correctly then the List of Image strings is updated in the variable searchResults. This variable is used by the composable UI to populate the LazyColumn.

We code the composable UI for this use case in the next chapter.

Please checkout chapter 6 to recap the code.

The ImageResultDto and ImageResponseDto data classes showcase our DTO. The DTO to Domain layer mapper functions produces the ImageResult objects that satisfy the SearchImageUseCase.

Now we come to the important part - API Service.

ImageAPI

package com.learning.artsnapapp.data.remote.api

import com.learning.artsnapapp.data.remote.dto.ImageResponseDto
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Query

interface ImageApi {

    @GET(".")
    suspend fun searchImages(
        @Query("key") apiKey:String,
        @Query("q") searchQuery: String,
    ) : Response<ImageResponseDto>
}

The ImageAPI interface defines the searchImages function which takes the user Query as the parameter. The second parameter is the API key used for Pixabay. The reader is encouraged to login to the Pixabay website and obtain the API Key.

The searchImages() function will now be implemented in the ArtRepositoryImpl class. We already have the code below from chapter 7. This class used the ArtDao object to fetch records from the Room DB. This class had three more functions that were not implemented. Now is the time to jump in and implement the searchImage() function. To implement the searchImage function we need to inject the ImageApi and the API key.

/**
 * Implementation of [ArtRepositoryInterface].
 *
 * This class acts as a single source of truth for both local (Room) and
 * remote (Pixabay API) data. It maps entities and DTOs to domain models.
 *
 * Dependencies are injected using Hilt:
 * - [ArtDao] for local persistence.
 * - [ImageApi] for remote API access.
 * - `@Named("apiKey")` String for API authentication.
 *
 * The [searchImage] function emits a [Resource] stream, which allows the
 * UI layer to react to loading, success, and error states.
 */

@Singleton
class ArtRepositoryImpl @Inject constructor(
    private val artDao: ArtDao,
    private val imageApi: ImageApi,
    @Named("apiKey") private val apiKey: String
):ArtRepositoryInterface {
    override fun getArt(): Flow<List<Art>> {

        //returns a stream (Flow) that emits a list of ArtEntity objects every time the ROOM DB table changes.
        val artStream = artDao.getAllArts()

       val artObjs = artStream.map { entityList -> entityList.map { it.toDomainModel() } }
        return artObjs
    }

    override fun insertArt(art: Art) {
        TODO("Not yet implemented")
    }

    override fun deleteArt(art: Art) {
        TODO("Not yet implemented")
    }

     override fun searchImage(imageString: String): Flow<Resource<List<ImageResult>>> = flow {
        emit(Resource.loading())

        try {
            val response = imageApi.searchImages(apiKey, imageString)

            if (response.isSuccessful) {
                val body = response.body()
                if (body != null) {
                    // Map the list of DTOs to domain models
                    val results = body.hits.map {it.toDomainModel()}
                    emit(Resource.success(results))
                } else {
                    emit(Resource.error("Empty response body"))
                }
            } else {
                emit(Resource.error("API error: ${response.message()}"))
            }

        } catch (e: Exception) {
            emit(Resource.error("Network error: ${e.message}"))
        }
    }

}

The ImageApi will be provided by Hilt. So we update the AppModule class present in the “di” package

Also The ArtUseCases will be updated with the SearchImageUseCase.

@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    @Singleton
    fun provideDatabase(@ApplicationContext context: Context): ArtDatabase = Room.databaseBuilder(
        context,
        ArtDatabase::class.java,
        "art_db"
    ).build()

    @Provides
    fun provideArtDao(db: ArtDatabase) : ArtDao = db.artDao()

    @Provides
    @Singleton
    fun provideRetrofitApi():ImageApi = Retrofit.Builder()
        .baseUrl(BuildConfig.BASE_URL)
        .addConverterFactory(GsonConverterFactory.create())
        .build().create(ImageApi::class.java)

    @Provides
    @Singleton
    @Named("apiKey")
    fun provideImageApiKey() : String = BuildConfig.PIXABAY_API_KEY


    // --- USE CASES ----------------------------------------------------------
    @Provides
    @Singleton
    fun provideArtUseCases(repository: ArtRepositoryInterface): ArtUseCases =
        ArtUseCases(
            getArtUseCase = GetArtUseCase(repository),
            searchImageUseCase = SearchImageUseCase(repository)
        )
}

/**
 *
 * - The Pixabay API key is stored locally (in local.properties) for security.
 * - The key is injected into BuildConfig at compile-time.
 * - Access it anywhere using BuildConfig.PIXABAY_API_KEY.
 * - Never commit local.properties to version control.
 */

The app level build.gradle.kts will be updated for the PIXABAY_API_KEY and BASE_URL. The actual PIXABAY_API_KEY will reside in the local.properties.

Ensure you cannot commit this local.properties to your GIT remote repository.

PIXABAY_API_KEY=12345678-abcdefg

 defaultConfig {
        applicationId = "com.learning.artsnapapp"
        minSdk = 29
        targetSdk = 36
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

            buildConfigField(
                "String",
                "PIXABAY_API_KEY",
                "\"${project.findProperty("PIXABAY_API_KEY") ?: ""}\""
            )
        buildConfigField(
            "String",
            "BASE_URL",
            "\"https://pixabay.com/api/\""
        )

    }

The data layer code is now complete for the SearchImageUseCase

In the next chapter we will update the ArtViewModel class followed by the new Composable for the SearchImageUseCase.

DATA FLOW DIAGRAM

flowchart TD

%% ===== Domain Layer =====
subgraph Domain["Domain Layer"]
    A1[ArtRepositoryInterface]:::interface
    A2[SearchImageUseCase]:::usecase
    A2 --> A1
end

%% ===== Data Layer =====
subgraph Data["Data Layer"]
    B1[ArtRepositoryImpl]:::repo
    B2[ImageApi Retrofit]:::api
    B3[ImageResultDto / ImageResponse]:::dto
    B4[Mapper: toImageResult]:::mapper

    B1 --> B2
    B2 --> B3
    B3 --> B4
end

%% ===== Hilt =====
subgraph Hilt["Hilt Dependency Injection"]
    C1[AppModule]:::module
    C1 --> B2
    C1 --> B1
end

%% ===== Presentation Layer =====
subgraph Presentation["Presentation Layer"]
    D1[ImageSearchViewModel]:::vm
    D2[ImageSearchScreen Compose]:::ui
    D2 --> D1
    D1 --> A2
end

%% ===== Relationships =====
A1 -.-> B1
C1 --> D1

%% ===== Styling =====
classDef interface fill:#f6d6ad,stroke:#dba45e,stroke-width:1px,color:#000
classDef usecase fill:#d6f5e1,stroke:#2a9d8f,stroke-width:1px,color:#000
classDef repo fill:#ffd6a5,stroke:#f4a261,stroke-width:1px,color:#000
classDef api fill:#f7ede2,stroke:#e76f51,stroke-width:1px,color:#000
classDef dto fill:#e9ecef,stroke:#adb5bd,stroke-width:1px,color:#000
classDef mapper fill:#dee2e6,stroke:#6c757d,stroke-width:1px,color:#000
classDef module fill:#bde0fe,stroke:#4361ee,stroke-width:1px,color:#000
classDef vm fill:#d4a5ff,stroke:#7209b7,stroke-width:1px,color:#000
classDef ui fill:#ffc8dd,stroke:#b5179e,stroke-width:1px,color:#000

• Domain layer defines business logic and repository contracts.

• Data layer implements actual API calls (Retrofit) and maps DTOs → Domain Models.

• Hilt provides singletons of API, Repository, and UseCases for dependency injection.

• ViewModel consumes UseCases and exposes state to UI via StateFlow.

• Composables observe ViewModel state and render UI accordingly.

• Clean flow: UI → ViewModel → UseCase → Repository → API → Mapper → Domain Model.

Coding the Domain Model

The ImageResult class

package com.learning.artsnapapp.domain.model

data class ImageResult (
    val id: Int,
    val previewURL: String,
    val largeImageURL: String
)

The Repository Interface

Let us check the repository interface that we used for our first use case.

package com.learning.artsnapapp.domain.repository

import com.learning.artsnapapp.domain.model.Art
import com.learning.artsnapapp.domain.model.ImageResult
import com.learning.artsnapapp.util.Resource
import kotlinx.coroutines.flow.Flow

interface ArtRepositoryInterface {

    suspend fun insertArt(art: Art)
    suspend fun deleteArt(art: Art)
    fun getArt(): Flow<List<Art>>
    fun searchImage(imageString: String): Flow<Resource<List<ImageResult>>>
}

/**
 The domain layer defines what data is needed, not how it is fetched.
 The data layer will implement this interface.
 * */

We already defined the searchImage function that will return Flow of the List of ImageResult objects. This is similar to the getArt function returning the List of Art objects that we have already worked on in the previous chapters.

We are walking on the already trodden path and things will be simpler to understand this time around. The power of clarity that the Clean Architecture provides will be seen here. We have already worked on the Hilt dependency injection and hence this time we will re-use what is already done to build this SearchImageUseCase functionality quickly.

Here is the use case code

package com.learning.artsnapapp.domain.usecase

import com.learning.artsnapapp.domain.model.ImageResult
import com.learning.artsnapapp.domain.repository.ArtRepositoryInterface
import com.learning.artsnapapp.util.Resource
import kotlinx.coroutines.flow.Flow

class SearchImageUseCase(private val imageRepository: ArtRepositoryInterface)
{

    operator fun invoke(searchQuery:String) : Flow<Resource<List<ImageResult>>> {
        return imageRepository.searchImage(searchQuery)
    }

}

//Purpose: Search for artwork images online using the external remote API.
//Domain logic: Wrap API responses into Resource and map DTO → domain model.

We need to understand the Resource utility class. There is a separate package “util” to handle utility classes.

The RESOURCE class

package com.learning.artsnapapp.util

sealed class Resource<T>(
    val data: T? = null,
    val message: String? = null
) {
    class Success<T>(data: T) : Resource<T>(data)
    class Error<T>(message: String, data: T? = null) : Resource<T>(data, message)
    class Loading<T>(data: T? = null) : Resource<T>(data)

    companion object {
        fun <T> success(data: T): Resource<T> = Success(data)
        fun <T> error(msg: String, data: T? = null): Resource<T> = Error(msg, data)
        fun <T> loading(data: T? = null): Resource<T> = Loading(data)
    }
}

Resource - A wrapper class that represents Loading, Success, or Error for any data type. To make UI and ViewModel communication cleaner and handle async states elegantly.

• Resource is not about data, it’s about data state.

• It helps ViewModels and Composables talk in the same structured language

• Benefits - Predictable state management, no null-check hell, smoother Compose UI updates.

KOTLIN SEALED CLASS AND BENEFITS

A sealed class in Kotlin is a restricted class hierarchy — it allows you to define a fixed set of subclasses that represent different variants of a concept.

You can think of it like a closed family of related classes. Only the types you declare inside it are allowed to exist — nothing else can extend it.

Why Use Sealed Classes?

• Type-safe state management You can handle different outcomes (like Success, Error, Loading) clearly.

• No magic numbers or enums Instead of using strings or codes (“STATUS=200”), each state is an actual class.

• Smart compiler help If you forget to handle a state in a when block, the compiler warns you

In the next chapter, we will code the data layer for the SearchImageUseCase.

Let us now introduce Hilt Dependency Injection. Now, if something breaks, then we know that the Hilt code has something erroneous.

STEPS TO INJECT HILT

• @HiltAndroidApp → Application class

• @Module @InstallIn(SingletonComponent::class) → Provide repository + use cases

• @HiltViewModel → Automatically inject ArtUseCases into your ViewModel

The code snippets are shown below

package com.learning.artsnapapp

import android.app.Application
import dagger.hilt.android.HiltAndroidApp

/**
 * ## ArtApplication
 *
 * This is the root of the dependency graph.
 * Hilt automatically generates the components for the app.
 */
@HiltAndroidApp
class ArtApplication : Application() {
}

/**

 * • Must be declared in `AndroidManifest.xml` under `<application android:name="...">`.  
 * • Required once — this bootstraps Hilt globally.  
 * • All other injections depend on this root setup.  
 */

This application class should be named in the AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <application
        android:name="com.learning.artsnapapp.ArtApplication"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.ArtLearnersApp"
        >
        <activity
            android:name="com.learning.artsnapapp.MainActivity"
            android:exported="true"
            android:label="@string/app_name"
            android:theme="@style/Theme.ArtLearnersApp"
           >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

The MainActivity is without fake repository now. Real dependencies wired via Hilt.

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels

import com.learning.artsnapapp.presentation.artlist.ArtListScreen
import com.learning.artsnapapp.presentation.viewmodel.ArtViewModel
import com.learning.artsnapapp.ui.theme.ArtLearnersAppTheme
import androidx.compose.runtime.collectAsState
import dagger.hilt.android.AndroidEntryPoint

/**
 * ## MainActivity
 *
 * Entry activity that hosts composables and enables Hilt injection.
 */
@AndroidEntryPoint
class MainActivity : ComponentActivity() {

    private val viewModel: ArtViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
         setContent {
            val viewModel: ArtViewModel = hiltViewModel()
            ArtListScreen(viewModel)
        }
    }
}
/**

 * • `@AndroidEntryPoint` is required on any Activity, Fragment, or Composable host 
 *   that requests injected dependencies.  
 * • You can now retrieve your Hilt ViewModel using `hiltViewModel()`.  
 * • Make sure all parent components are also annotated if nesting Fragments.  
 */

We have a new package at the same hierarchy as the data folder.

package com.learning.artsnapapp.di

import com.learning.artsnapapp.data.repo.ArtRepositoryImpl
import com.learning.artsnapapp.domain.repository.ArtRepositoryInterface
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton

/**
 * Binds the repository implementation to its interface
 * so that Hilt can provide it wherever the interface is required.
 */
/**
 * ## RepositoryModule
 *
 * Binds the concrete [ArtRepositoryImpl] to its interface [ArtRepositoryInterface].
 *
 * This allows ViewModels and UseCases to depend on the *interface*,
 * while Hilt injects the *implementation* automatically.
 */
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {

   /**
     * Binds [ArtRepositoryImpl] to [ArtRepositoryInterface].
     *
     * @return The implementation that Hilt should provide whenever
     * [ArtRepositoryInterface] is requested.
     */
    @Binds
    @Singleton
    abstract fun bindArtRepository(
        impl: ArtRepositoryImpl
    ): ArtRepositoryInterface
}

/**

 * • @Binds → Used when you already have an implementation class (no need to `@Provides`).
 * • Promotes **dependency inversion** — ViewModels use the interface, not the concrete class.
 * • Keeps your architecture clean and testable.
 * • This pairs perfectly with AppModule — together, they build your DI graph.
 */

package com.learning.artsnapapp.di

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import com.learning.artsnapapp.BuildConfig
import com.learning.artsnapapp.data.local.dao.ArtDao
import com.learning.artsnapapp.data.local.db.ArtDatabase
import com.learning.artsnapapp.data.remote.api.ImageApi
import com.learning.artsnapapp.domain.repository.ArtRepositoryInterface
import com.learning.artsnapapp.domain.usecase.ArtUseCases
import com.learning.artsnapapp.domain.usecase.DeleteArtUseCase
import com.learning.artsnapapp.domain.usecase.GetArtUseCase
import com.learning.artsnapapp.domain.usecase.InsertArtUseCase
import com.learning.artsnapapp.domain.usecase.SearchImageUseCase
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.create
import javax.inject.Named
import javax.inject.Singleton

/**
 * ## AppModule
 *
 * Provides **singleton dependencies** such as:
 * - Room database
 * - DAO
 * - Use cases (grouped in [ArtUseCases])
 *
 * Hilt uses this module to construct objects that are needed app-wide.
 */

@Module
@InstallIn(SingletonComponent::class)
object AppModule {

   /**
     * Provides a single instance of the Room Database.
     *
     * @param context Application context automatically injected by Hilt.
     */
    @Provides
    @Singleton
    fun provideDatabase(@ApplicationContext context: Context): ArtDatabase = Room.databaseBuilder(
        context,
        ArtDatabase::class.java,
        "art_db"
    ).build()

   /**
     * Provides the DAO object to access the `Art` table.
     */
    @Provides
    fun provideArtDao(db: ArtDatabase) : ArtDao = db.artDao()

    /**
     * Provides all use cases (business logic) bundled in [ArtUseCases].
     *
     * @param repository Injected automatically from [RepositoryModule].
     */
    // --- USE CASES ----------------------------------------------------------
    @Provides
    @Singleton
    fun provideArtUseCases(repository: ArtRepositoryInterface): ArtUseCases =
        ArtUseCases(
            getArtUseCase = GetArtUseCase(repository),
        )
}

/*
     @Module → tells Hilt this class provides dependencies.

 * • @InstallIn(SingletonComponent::class) → dependencies live for the app’s lifetime.  
 * • @Provides → defines *how to create* each dependency.  
 * • Hilt automatically injects these wherever needed (e.g., ViewModel, Repository).  
*/

We have a special data class in the domain/usecase package - ArtUseCases

//aggregating all use cases
data class ArtUseCases(
   val getArtUseCase: GetArtUseCase,
)

//Each use case represents one piece of
// business logic and depends only on the repository interface, 
//not on Room or Retrofit directly.
//They make the domain layer pure, testable, and independent of framework details.

The comments added at the end of each class as comments explain the code in an easy language.

We will now modify the ArtViewModel to accept these Hilt dependencies.

/**
 * ## ArtViewModel
 *
 * ViewModel that fetches art data from repository through use cases.
 */

@HiltViewModel
class ArtViewModel @Inject constructor(
    private val useCases: ArtUseCases
) : ViewModel() {

    /**
     * A **mutable** StateFlow holding the current list of artworks.
     * This is **private** so that only the ViewModel can modify it.
     *
     * Initially empty; updated when Room emits new data through the use case.
     */
    private val _arts = MutableStateFlow<List<Art>>(emptyList())

    /**
     * A **read-only** version of [_arts] exposed to the UI.
     * Compose collects this to display the current artwork list.
     *
     * > `StateFlow` is a hot flow — it always has a current value
     *   and re-emits it to new collectors (like Compose recompositions).
     */
    val arts: StateFlow<List<Art>> = _arts.asStateFlow()

    /**
     * Indicates whether the app is currently fetching data.
     *
     * Mutable version (internal to the ViewModel).
     */
    private val _isLoading = MutableStateFlow(false)

    /**
     * Public, read-only version of [_isLoading] for the UI.
     *
     * The Compose layer can observe this to show/hide progress indicators.
     */
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()

    /**
     * Holds the latest error message, if any.
     *
     * `null` means no error.
     */
    private val _errorMessage = MutableStateFlow<String?>(null)

    /**
     * Public, read-only flow exposing error messages.
     */
    val errorMessage: StateFlow<String?> = _errorMessage.asStateFlow()

    /**
     * When ViewModel is created, it automatically loads artworks.
     * This is done inside [init] to trigger the use case once at startup.
     */
    init {
        loadArts()
    }

    /**
     * Invokes [GetArtUseCase] and collects the emitted Flow<List<Art>>.
     *
     * ### Flow explanation:
     * - The `GetArtUseCase()` returns a `Flow<List<Art>>`.
     * - A **Flow** is a cold asynchronous data stream — it emits values
     *   (here, lists of Art) over time.
     * - Room emits updates via Flow whenever the DB changes.
     *
     * ### Steps:
     * 1. Set loading state to `true`.
     * 2. Collect emitted art lists from use case.
     * 3. Update `_arts` StateFlow (Compose UI reacts automatically).
     * 4. Handle exceptions by updating `_errorMessage`.
     * 5. Set loading back to `false` when done.
     */
    private fun loadArts() {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                // Collects flow from use case
                useCases.getArtUseCase().collect { artList ->
                    _arts.value = artList
                }
            } catch (e: Exception) {
                _errorMessage.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }
}
/**
 * • `@HiltViewModel` integrates Hilt into Android's ViewModel system.  
 * • The constructor params (like `ArtUseCases`) are auto-provided by Hilt.  
 * • `@Inject constructor(...)` tells Hilt how to build this ViewModel.  
 * • No need for a manual ViewModelFactory — Hilt handles it.  
 */

Change the ArtListScreen to accept Hilt.

@Composable
fun ArtListScreen(
    viewModel: ArtViewModel = hiltViewModel(),
    isLoading: Boolean = false,
    onFabClick: () -> Unit = {},
    onDeleteClick: (Art) -> Unit = {},
    errorMessage: String? = null
) {

    val artList by viewModel.arts.collectAsState()

    Scaffold(
        floatingActionButton = {
            FloatingActionButton(onClick = onFabClick) {
                Icon(Icons.Default.AddBox, contentDescription = "Add Art")
            }
        }
    ) { paddingValues ->
        Box(modifier = Modifier
            .fillMaxSize()
            .padding(paddingValues)
        ) {

            when {
                // ✅ Loading State
                isLoading -> {
                    CircularProgressIndicator(
                        modifier = Modifier
                            .align(Alignment.Center)
                            .testTag("Progress")
                    )
                }

                // ✅ Error State
                errorMessage != null -> {
                    Text(
                        text = errorMessage,
                        color = Color.Red,
                        modifier = Modifier
                            .align(Alignment.Center)
                            .testTag("ErrorMessage")
                    )
                }

                // ✅ Empty List State
                artList.isEmpty() -> {
                    Text(
                        text = "No artworks found!",
                        modifier = Modifier.align(Alignment.Center)
                    )
                }

                // ✅ Normal List
                else -> {
                    LazyColumn(
                        modifier = Modifier.fillMaxSize()
                    ) {
                        items(artList) { art ->
                            ListItem(
                                headlineContent = { Text(art.name) },
                                supportingContent = { Text("${art.artistName} (${art.year})") },
                                trailingContent = {
                                    IconButton(onClick = { onDeleteClick(art) }) {
                                        Icon(
                                            Icons.Default.Delete,
                                            contentDescription = "Delete"
                                        )
                                    }
                                }
                            )
                            HorizontalDivider()
                        }
                    }
                }
            }
        }
    }
}

Change the ArtRepositoryImpl class as well.

@Singleton
class ArtRepositoryImpl @Inject constructor(private val artDao: ArtDao):ArtRepositoryInterface {
    override fun getArt(): Flow<List<Art>> {

        //returns a stream (Flow) that emits a list of ArtEntity objects every time the ROOM DB table changes.
        val artStream = artDao.getAllArts()

       val artObjs = artStream.map { entityList -> entityList.map { it.toDomainModel() } }
        return artObjs
    }

    override fun insertArt(art: Art) {
        TODO("Not yet implemented")
    }

    override fun deleteArt(art: Art) {
        TODO("Not yet implemented")
    }

    override fun searchImage(userQuery: String): Flow<Resource<List<ImageResult>>> {
        TODO("Not yet implemented")
    }
}

Now run the app and we have successfully implemented the Hilt Dependency Injection.

The above code is an instrumentation test and will run on an android device or emulator.

We test the following

• The fake data appears on screen

• Loading & error states behave as expected.

Test 1 : artListScreen_displaysArtListCorrectly

Purpose

Verifies that the UI displays the list of artworks correctly when provided with sample data.

Setup

• Creates a list of two Art objects (Starry Horse and Mano ya na mano).

• Renders the ArtListScreen composable with this list.

Assertions

• Ensures that both artwork titles are visible on the screen using onNodeWithText().assertIsDisplayed().

• Confirms that LazyColumn correctly renders multiple items.

Summary

• This is a sanity UI test — checks that Compose correctly binds data to the visible layout.

• It doesn’t depend on any repository or ViewModel — pure composable test.

Test 2 : artListScreen_showsLoadingIndicatorWhenLoading

Purpose

Validates that the progress indicator (loading spinner) is displayed when the screen is in a loading state.

Setup

• Passes isLoading = true to ArtListScreen.

• Uses a Modifier.testTag("Progress") for the loading indicator in the composable.

Assertions

• Checks that a node with tag "Progress" exists on the screen (assertExists()).

Summary

• Helps verify that UI reacts properly to loading state changes.

• In the real app, this state will be controlled by viewModel.isLoading.

• This is important for user feedback during data fetching.

Test 3 : artListScreen_displaysErrorMessageWhenErrorOccurs

Purpose

Checks that an error message is displayed if something goes wrong.

Setup

• Renders ArtListScreen with errorMessage = "Something went wrong".

• Passes an empty artList (since we’re only testing error display).

Assertions

• Verifies that the error text is visible on the screen using onNodeWithText("Something went wrong").assertIsDisplayed().

Summary

• Simulates the scenario where a Room query fails.

• Confirms that the user is not left with a blank screen but sees a clear error message.

• This test ensures that your UI reacts correctly to error state updates from the ViewModel.

FINAL SUMMARY

These three tests together verify UI reactivity — the most important principle of Jetpack Compose.
They prove that when the ViewModel updates the StateFlow (data, loading, error), the UI layer reflects those changes instantly and correctly.

flowchart LR

    A[Repository - Fake or Real] --> B[UseCase - GetArtUseCase]
    B --> C[ArtViewModel - holds StateFlows]
    C --> D[ArtListScreen - observes data]
    D --> E[Compose UI Tests]
    E --> E1[Test: Show List]
    E --> E2[Test: Show Loading]
    E --> E3[Test: Show Error]

    subgraph Domain [Domain Layer]
        A
        B
    end

    subgraph Presentation [Presentation Layer]
        C
        D
    end

    subgraph Testing [Testing Layer]
        E
        E1
        E2
        E3
    end

The flowchart sums up the work that we have done so far.

package androidavatar.learning.artlearnersapp.presentation.artlist

import androidavatar.learning.artlearnersapp.domain.model.Art
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AddBox
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Divider
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.testTag

@Composable
fun ArtListScreen(
    artList: List<Art>,
    isLoading: Boolean = false,
    onFabClick: () -> Unit = {},
    onDeleteClick: (Art) -> Unit = {},
    errorMessage: String? = null
) {
    Scaffold(
        floatingActionButton = {
            FloatingActionButton(onClick = onFabClick) {
                Icon(Icons.Default.AddBox, contentDescription = "Add Art")
            }
        }
    ) { paddingValues ->
        Box(modifier = Modifier
            .fillMaxSize()
            .padding(paddingValues)
        ) {

            when {
                // ✅ Loading State
                isLoading -> {
                    CircularProgressIndicator(
                        modifier = Modifier
                            .align(Alignment.Center)
                            .testTag("Progress")
                    )
                }

                // ✅ Error State
                errorMessage != null -> {
                    Text(
                        text = errorMessage,
                        color = Color.Red,
                        modifier = Modifier
                            .align(Alignment.Center)
                            .testTag("ErrorMessage")
                    )
                }

                // ✅ Empty List State
                artList.isEmpty() -> {
                    Text(
                        text = "No artworks found!",
                        modifier = Modifier.align(Alignment.Center)
                    )
                }

                // ✅ Normal List
                else -> {
                    LazyColumn(
                        modifier = Modifier.fillMaxSize()
                    ) {
                        items(artList) { art ->
                            ListItem(
                                headlineContent = { Text(art.name) },
                                supportingContent = { Text("${art.artistName} (${art.year})") },
                                trailingContent = {
                                    IconButton(onClick = { onDeleteClick(art) }) {
                                        Icon(
                                            Icons.Default.Delete,
                                            contentDescription = "Delete"
                                        )
                                    }
                                }
                            )
                            Divider()
                        }
                    }
                }
            }
        }
    }
}

The layout has a “fab” button at the right-end bottom corner. The list of image records are displayed from the Room DB using Lazy Column. We have already discussed this process in depth in the earlier chapters.

Modifying the MainActivity to visualise the screen

Now modify the MainActivity (this is the entry point) of the app.

class MainActivity : ComponentActivity() {

    // Fake repository for now
    private val fakeRepository = object : ArtRepositoryInterface {
        override fun getArt(): Flow<List<Art>> = flow {
            emit(
                listOf(
                    Art(1, "Starry Horse", "Viru Pandey", "1904", "url1"),
                    Art(2, "Mano ya na mano", "Satish Shah", "1998", "url2")
                )
            )
        }

        override fun insertArt(art: Art) {}
        override fun deleteArt(art: Art) {}
        override fun searchImage(userQuery: String): Flow<Resource<List<ImageResult>>> =
            flow { emit(Resource.Success(emptyList())) }
    }

    private val getArtUseCase = GetArtUseCase(fakeRepository)
    private val viewModel by viewModels<ArtViewModel> {
        object :  ViewModelProvider.Factory {
            override fun <T : ViewModel> create(modelClass: Class<T>): T {
                return ArtViewModel(getArtUseCase) as T
            }
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val arts by viewModel.arts.collectAsState()

            ArtListScreen(
                artList = arts,
                onFabClick = { /* handle add */ },
                onDeleteClick = { }
            )
        }
    }
}

Now we have introduced the fake repository and wired all the connections. Later on we will remove the fake dependencies and introduce Hilt to upgrade our code that will be production ready.

You will see the two Art objects as two list elements.

Kudos for coming thus far and you have the first composable screen with end-to-end code.

In the next chapter we will add the tests for the composable ArtListScreen and wrap up the code!