Merge pull request #3 from MoscowSquad/feature/get-weather-info-usecase

Add unit tests for getCurrentWeatherUseCase to validate data accuracy and edge case handling

Author: AimanYosofiUlt

build.gradle.kts

@@ -24,15 +24,20 @@ dependencies {
     testImplementation("com.google.truth:truth:1.4.2")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
-
     implementation("io.ktor:ktor-client-core:2.3.13")
     implementation("io.ktor:ktor-client-cio:2.3.13")
     testImplementation("io.ktor:ktor-client-mock:2.3.13")
 
     implementation("ch.qos.logback:logback-classic:1.5.6")
-
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0")
-}
+    val ktor_version = "2.3.10"
+    implementation("io.ktor:ktor-client-core:$ktor_version")
+    implementation("io.ktor:ktor-client-cio:$ktor_version")
+    implementation("io.ktor:ktor-client-content-negotiation:$ktor_version")
+    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktor_version")
+
+
+    }
 
 tasks.test {
     useJUnitPlatform()

src/main/kotlin/data/repository/WeatherRepositoryImpl.kt

@@ -1,5 +1,33 @@
 package data.repository
 
-import domain.repository.WeatherRepository
+import WeatherRepository
+import domain.models.CurrentWeather
+import domain.models.exceptions.FailedFetchWeatherDataException
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
 
-class WeatherRepositoryImpl : WeatherRepository
+const val OPEN_METO_API = "https://api.open-meteo.com/v1/forecast"
+
+class WeatherRepositoryImpl(private val httpClient: HttpClient) : WeatherRepository {
+    override suspend fun getCurrentWeather(latitude: Double, longitude: Double): CurrentWeather {
+        val response: HttpResponse = httpClient.get(OPEN_METO_API) {
+            parameter("latitude", latitude)
+            parameter("longitude", longitude)
+            parameter(
+                "current",
+                "temperature_2m,relative_humidity_2m,apparent_temperature,is_day,wind_speed_10m,snowfall,rain,weather_code,cloud_cover"
+            )
+        }
+
+        if (!response.status.isSuccess()) {
+            throw FailedFetchWeatherDataException(
+                "Weather API returned error status: ${response.status}"
+            )
+        }
+
+        return response.body()
+    }
+}

src/main/kotlin/domain/models/CurrentWeather.kt

@@ -8,8 +8,7 @@ data class CurrentWeather(
     @SerialName("temperature_2m") val temperature2m: Double,
     @SerialName("relative_humidity_2m") val relativeHumidity2m: Double,
     @SerialName("apparent_temperature") val apparentTemperature: Double,
-    @SerialName("is_day") val isDay: Double,
-    val precipitation: Double,
+    @SerialName("is_day") val isDay: Int,
     val rain: Double,
     val snowfall: Double,
     @SerialName("cloud_cover") val cloudCover: Double,

src/main/kotlin/domain/models/exceptions/FailedFetchWeatherDataException.kt

@@ -0,0 +1,6 @@
+package domain.models.exceptions
+
+class FailedFetchWeatherDataException(
+    message: String,
+    cause: Throwable? = null
+) : Exception(message, cause)

src/main/kotlin/domain/repository/WeatherRepository.kt

@@ -1,3 +1,5 @@
-package domain.repository
+import domain.models.CurrentWeather
 
-interface WeatherRepository
+interface WeatherRepository {
+    suspend fun getCurrentWeather(latitude: Double, longitude: Double): CurrentWeather
+}

src/main/kotlin/domain/use_cases/GetCurrentWeatherUseCase.kt

@@ -1,9 +1,7 @@
-package domain.use_cases
+import domain.models.CurrentWeather
 
-import domain.repository.WeatherRepository
-
-class GetCurrentWeatherUseCase(
-    private val weatherRepository: WeatherRepository
-) {
-
-}
+class GetCurrentWeatherUseCase(private val repository: WeatherRepository) {
+    suspend fun getCurrentWeather(latitude: Double, longitude: Double): CurrentWeather {
+        return repository.getCurrentWeather(latitude, longitude)
+    }
+}

src/test/kotlin/domain/use_cases/GetCurrentWeatherUseCaseTest.kt

@@ -0,0 +1,113 @@
+package domain.use_cases
+
+import GetCurrentWeatherUseCase
+import WeatherRepository
+import com.google.common.truth.Truth
+import com.google.common.truth.Truth.assertThat
+import domain.models.CurrentWeather
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+class GetCurrentWeatherUseCaseTest {
+
+    private lateinit var weatherRepository: WeatherRepository
+    private lateinit var getCurrentWeatherUseCase: GetCurrentWeatherUseCase
+
+    private val latitude = 55.7558
+    private val longitude = 37.6173
+    private val expectedWeather = CurrentWeather(
+        temperature2m = 12.5,
+        relativeHumidity2m = 67.0,
+        apparentTemperature = 11.2,
+        isDay = 1,
+        rain = 0.1,
+        snowfall = 0.0,
+        cloudCover = 65.0,
+        windSpeed10m = 6.8,
+    )
+
+    @BeforeEach
+    fun setup() {
+        weatherRepository = mockk(relaxed = true)
+        getCurrentWeatherUseCase = GetCurrentWeatherUseCase(weatherRepository)
+    }
+
+    @Test
+    fun `should get the current weather from the WeatherRepository when getting the current weather`() =
+        runTest {
+            // Given
+            coEvery { weatherRepository.getCurrentWeather(latitude, longitude) } returns expectedWeather
+
+            // When
+            val result = getCurrentWeatherUseCase.getCurrentWeather(latitude, longitude)
+
+            // Then
+            coVerify(exactly = 1) { weatherRepository.getCurrentWeather(latitude, longitude) }
+        }
+
+    @Test
+    fun `should return current weather for given coordinates when getting the current weather`() = runTest {
+        // Given
+        coEvery { weatherRepository.getCurrentWeather(latitude, longitude) } returns expectedWeather
+
+        // When
+        val result = getCurrentWeatherUseCase.getCurrentWeather(latitude, longitude)
+
+        // Then
+        Truth.assertThat(expectedWeather).isEqualTo(result)
+    }
+
+    @Test
+
+    fun `fun getCurrentWeather() should throw exception when repository fails`() = runTest {
+
+        // Given
+        val exceptionMessage = "API error"
+        coEvery { weatherRepository.getCurrentWeather(latitude, longitude) } throws RuntimeException(exceptionMessage)
+
+        // When / Then
+        val exception = assertThrows<RuntimeException> {
+            getCurrentWeatherUseCase.getCurrentWeather(latitude, longitude)
+        }
+
+        // Assert
+        assertThat(exception.message).isEqualTo(exceptionMessage)
+    }
+
+    @Test
+    fun `getCurrentWeather() should return expected weather data when valid latitude and longitude are provided()`() =
+        runTest {
+            // Given
+            val testLat = 33.3
+            val testLon = 44.4
+            val expected = expectedWeather.copy(temperature2m = 25.0)
+            coEvery { weatherRepository.getCurrentWeather(testLat, testLon) } returns expected
+
+            // When
+            val result = getCurrentWeatherUseCase.getCurrentWeather(testLat, testLon)
+
+            // Then
+            coVerify { weatherRepository.getCurrentWeather(testLat, testLon) }
+            assertThat(result).isEqualTo(expected)
+        }
+
+
+    @Test
+    fun `getCurrentWeather() should call repository with zero coordinates when latitude and longitude are both zeros`() =
+        runTest {
+            val zeroLat = 0.0
+            val zeroLon = 0.0
+            coEvery { weatherRepository.getCurrentWeather(zeroLat, zeroLon) } returns expectedWeather
+
+            // When
+            getCurrentWeatherUseCase.getCurrentWeather(zeroLat, zeroLon)
+
+            // Then
+            coVerify { weatherRepository.getCurrentWeather(zeroLat, zeroLon) }
+        }
+}