veterinary-practice/src/test/kotlin/database/search/SearchDatabaseTest.kt at e89e6a48cf55c9454deebe7f5628785d04b290f1 · SandBoxDeveloper/veterinary-practice · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package database.search

import com.google.common.truth.Truth.assertThat
import database.LocalDatabase
import database.entity.CustomerEntity
import database.entity.PetEntity
import database.mapper.CustomerEntityMapper
import database.mapper.PetEntityMapper
import database.model.SearchQueryResult
import io.mockk.MockKAnnotations
import io.mockk.every
import io.mockk.impl.annotations.MockK
import model.Customer
import model.Pet
import org.junit.Test
import kotlin.test.BeforeTest

class SearchDatabaseTest {

    @MockK
    lateinit var mockLocalDatabase: LocalDatabase

    @MockK
    lateinit var mockCustomerEntityMapper: CustomerEntityMapper

    @MockK
    lateinit var mockPetEntityMapper: PetEntityMapper

    private val subject by lazy { SearchDatabase(mockLocalDatabase, mockCustomerEntityMapper, mockPetEntityMapper) }

    @BeforeTest
    fun setUp() {
        MockKAnnotations.init(this)
        every { mockLocalDatabase.getAllCustomers() } returns hashMapOf(Pair("1", Customer("1", "Albert")))
        every { mockLocalDatabase.getAllPets() } returns hashMapOf(Pair("1", Pet("1", "Johnny", "Dog", "1")))
    }

    @Test
    fun `queryAllDatabaseTable() - given search query is empty SearchQueryResultError is returned with message`() {
        //given
        val query = ""

        //when
        val result = subject.queryAllDatabaseTable(query)

        //then
        assertThat(
            result
        ).isEqualTo(SearchQueryResult.Error("you didn't enter a query, please try again"))
    }

    @Test
    fun `queryAllDatabaseTable() - given search query is blank then SearchQueryResultError is returned with message`() {
        //given
        val query = " "

        //when
        val result = subject.queryAllDatabaseTable(query)

        //then
        assertThat(
            result
        ).isEqualTo(SearchQueryResult.Error("you didn't enter a query, please try again"))
    }

    @Test
    fun `queryAllDatabaseTable() - given query has a customer and pet match in the database then SearchQueryResultSuccess is returned with customer and pet`() {
        //given
        every { mockLocalDatabase.getAllCustomers() } returns hashMapOf(
            Pair("1", Customer("1", "Albert")),
            Pair("2", Customer("2", "Wilfred"))
        )
        every { mockLocalDatabase.getAllPets() } returns hashMapOf(
            Pair("3", Pet("3", "Wilfred", "Fish", "1"))
        )
        every { mockCustomerEntityMapper.map(any(), any()) } returns listOf(secondCustomerEntity)
        every { mockPetEntityMapper.map(any(), any()) } returns listOf(secondPetEntity)

        val query = "Wilfred"

        //when
        val result = subject.queryAllDatabaseTable(query)

        //then
        assertThat(
            result
        ).isEqualTo(SearchQueryResult.Success(customers = listOf(secondCustomerEntity), pets = listOf(secondPetEntity)))
    }

    @Test
    fun `queryAllDatabaseTable() - given query has a customer match only in the database then SearchQueryResultSuccess is returned with customer entity`() {
        //given
        val query = "Albert"
        every { mockCustomerEntityMapper.map(any(), any()) } returns listOf(customerEntity)
        every { mockPetEntityMapper.map(any(), any()) } returns emptyList()

        //when
        val result = subject.queryAllDatabaseTable(query)

        //then
        assertThat(
            result
        ).isEqualTo(SearchQueryResult.Success(customers = listOf(customerEntity), pets = emptyList()))
    }

    @Test
    fun `queryAllDatabaseTable() - given query has a pet match only in the database then SearchQueryResultSuccess is returned with pet entity`() {
        //given
        val query = "Johnny"
        every { mockPetEntityMapper.map(any(), any()) } returns listOf(petEntity)
        every { mockCustomerEntityMapper.map(any(), any()) } returns emptyList()

        //when
        val result = subject.queryAllDatabaseTable(query)

        //then
        assertThat(
            result
        ).isEqualTo(SearchQueryResult.Success(customers = emptyList(), pets = listOf(petEntity)))
    }

    @Test
    fun `queryAllDatabaseTable() - given query has no match at all in the database then SearchQueryResultError is returned with message`() {
        //given
        val query = "random name"

        //when
        val result = subject.queryAllDatabaseTable(query)

        //then
        assertThat(
            result
        ).isEqualTo(SearchQueryResult.Error("no match found"))
    }

    private companion object {
        val customerEntity = CustomerEntity("Albert", "1", "Johnny")
        val petEntity = PetEntity("Johnny", "Dog", "1", "Albert", "1")
        val secondCustomerEntity = CustomerEntity("Wilfred", "2", "")
        val secondPetEntity = PetEntity("Wilfred", "Fish", "3", "Albert", "1")
    }
}