Simplify network layer (#175)

* Use Ktor for network requests * Remove V0 version * Remove Retrofit dependency * Fix url * Update versions of dependencies * Revert kotlinx-datetime Due to https://github.com/Kotlin/kotlinx-datetime/issues/304 * Rename leftovers * Remove OkHttp * Remove unused manifest * Remove unused Hilt module * Fix building empty image URLs * Use OkHttp as engine for Ktor * Reduce visibility of internal classes * Fix first set up test * Store only auth token, not header * Remove UnitInfo/FoodInfo/VersionInfo/NewShoppingListItemInfo * Remove RecipeSummaryInfo and ShoppingListsInfo * Remove FullShoppingListInfo * Remove ParseRecipeURLInfo * Remove FullRecipeInfo * Sign out if access token does not work * Rename getVersionInfo method * Update version name
2023-11-05 15:01:19 +01:00
parent 888783bf14
commit 5ed1acb678
144 changed files with 1216 additions and 2796 deletions
--- a/app/src/test/java/gq/kirmanak/mealient/data/add/impl/AddRecipeRepoTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/add/impl/AddRecipeRepoTest.kt
@@ -9,15 +9,16 @@ import gq.kirmanak.mealient.datastore_test.PORRIDGE_RECIPE_DRAFT
 import gq.kirmanak.mealient.model_mapper.ModelMapper
 import gq.kirmanak.mealient.model_mapper.ModelMapperImpl
 import gq.kirmanak.mealient.test.BaseUnitTest
-import io.mockk.*
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.every
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
+import io.mockk.verify
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class AddRecipeRepoTest : BaseUnitTest() {

    @MockK(relaxUnitFun = true)
--- a/app/src/test/java/gq/kirmanak/mealient/data/auth/impl/AuthRepoImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/auth/impl/AuthRepoImplTest.kt
@@ -4,62 +4,59 @@ import com.google.common.truth.Truth.assertThat
 import gq.kirmanak.mealient.data.auth.AuthDataSource
 import gq.kirmanak.mealient.data.auth.AuthRepo
 import gq.kirmanak.mealient.data.auth.AuthStorage
-import gq.kirmanak.mealient.data.baseurl.ServerInfoRepo
+import gq.kirmanak.mealient.datasource.SignOutHandler
 import gq.kirmanak.mealient.datasource.runCatchingExceptCancel
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_API_AUTH_HEADER
 import gq.kirmanak.mealient.test.AuthImplTestData.TEST_API_TOKEN
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_AUTH_HEADER
 import gq.kirmanak.mealient.test.AuthImplTestData.TEST_PASSWORD
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_SERVER_VERSION_V0
 import gq.kirmanak.mealient.test.AuthImplTestData.TEST_TOKEN
 import gq.kirmanak.mealient.test.AuthImplTestData.TEST_USERNAME
 import gq.kirmanak.mealient.test.BaseUnitTest
-import io.mockk.*
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.confirmVerified
+import io.mockk.every
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class AuthRepoImplTest : BaseUnitTest() {

    @MockK
    lateinit var dataSource: AuthDataSource

-    @MockK
-    lateinit var serverInfoRepo: ServerInfoRepo
-
    @MockK(relaxUnitFun = true)
    lateinit var storage: AuthStorage

+    @MockK(relaxUnitFun = true)
+    lateinit var signOutHandler: SignOutHandler
+
    lateinit var subject: AuthRepo

    @Before
    override fun setUp() {
        super.setUp()
-        subject = AuthRepoImpl(storage, dataSource, logger)
+        subject = AuthRepoImpl(storage, dataSource, logger, signOutHandler)
    }

    @Test
    fun `when isAuthorizedFlow then reads from storage`() = runTest {
-        every { storage.authHeaderFlow } returns flowOf("", null, "header")
+        every { storage.authTokenFlow } returns flowOf("", null, "header")
        assertThat(subject.isAuthorizedFlow.toList()).isEqualTo(listOf(true, false, true))
    }

    @Test
    fun `when authenticate successfully then saves to storage`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
        coEvery { dataSource.authenticate(any(), any()) } returns TEST_TOKEN
        coEvery { dataSource.createApiToken(any()) } returns TEST_API_TOKEN
        subject.authenticate(TEST_USERNAME, TEST_PASSWORD)
        coVerify {
            dataSource.authenticate(eq(TEST_USERNAME), eq(TEST_PASSWORD))
-            storage.setAuthHeader(TEST_AUTH_HEADER)
+            storage.setAuthToken(TEST_TOKEN)
            dataSource.createApiToken(eq("Mealient"))
-            storage.setAuthHeader(TEST_API_AUTH_HEADER)
+            storage.setAuthToken(TEST_API_TOKEN)
        }
        confirmVerified(storage)
    }
@@ -74,7 +71,7 @@ class AuthRepoImplTest : BaseUnitTest() {
    @Test
    fun `when logout expect header removal`() = runTest {
        subject.logout()
-        coVerify { storage.setAuthHeader(null) }
+        coVerify { storage.setAuthToken(null) }
        confirmVerified(storage)
    }
 }
--- a/app/src/test/java/gq/kirmanak/mealient/data/auth/impl/AuthStorageImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/auth/impl/AuthStorageImplTest.kt
@@ -7,18 +7,16 @@ import com.google.common.truth.Truth.assertThat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidTest
 import gq.kirmanak.mealient.data.auth.AuthStorage
-import gq.kirmanak.mealient.data.auth.impl.AuthStorageImpl.Companion.AUTH_HEADER_KEY
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_AUTH_HEADER
+import gq.kirmanak.mealient.data.auth.impl.AuthStorageImpl.Companion.AUTH_TOKEN_KEY
+import gq.kirmanak.mealient.test.AuthImplTestData.TEST_TOKEN
 import gq.kirmanak.mealient.test.HiltRobolectricTest
 import io.mockk.MockKAnnotations
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
 import javax.inject.Inject

-@OptIn(ExperimentalCoroutinesApi::class)
@HiltAndroidTest
 class AuthStorageImplTest : HiltRobolectricTest() {

@@ -39,12 +37,12 @@ class AuthStorageImplTest : HiltRobolectricTest() {

    @Test
    fun `when authHeaderFlow is observed then sends value immediately`() = runTest {
-        sharedPreferences.edit(commit = true) { putString(AUTH_HEADER_KEY, TEST_AUTH_HEADER) }
-        assertThat(subject.authHeaderFlow.first()).isEqualTo(TEST_AUTH_HEADER)
+        sharedPreferences.edit(commit = true) { putString(AUTH_TOKEN_KEY, TEST_TOKEN) }
+        assertThat(subject.authTokenFlow.first()).isEqualTo(TEST_TOKEN)
    }

    @Test
    fun `when authHeader is observed then sends null if nothing saved`() = runTest {
-        assertThat(subject.authHeaderFlow.first()).isEqualTo(null)
+        assertThat(subject.authTokenFlow.first()).isEqualTo(null)
    }
 }
--- a/app/src/test/java/gq/kirmanak/mealient/data/baseurl/ServerInfoRepoTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/baseurl/ServerInfoRepoTest.kt
@@ -1,21 +1,15 @@
 package gq.kirmanak.mealient.data.baseurl

 import com.google.common.truth.Truth.assertThat
-import gq.kirmanak.mealient.datasource.models.VersionInfo
-import gq.kirmanak.mealient.datasource_test.VERSION_INFO_V0
 import gq.kirmanak.mealient.test.AuthImplTestData.TEST_BASE_URL
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_VERSION
 import gq.kirmanak.mealient.test.BaseUnitTest
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
-import java.io.IOException

-@OptIn(ExperimentalCoroutinesApi::class)
 class ServerInfoRepoTest : BaseUnitTest() {

    private lateinit var subject: ServerInfoRepo
@@ -54,104 +48,10 @@ class ServerInfoRepoTest : BaseUnitTest() {

    @Test
    fun `when tryBaseURL succeeds expect call to storage`() = runTest {
-        coEvery { storage.getServerVersion() } returns null
        coEvery { storage.getBaseURL() } returns null
-        coEvery { dataSource.getVersionInfo() } returns VersionInfo(TEST_VERSION)
        subject.tryBaseURL(TEST_BASE_URL)
        coVerify {
            storage.storeBaseURL(eq(TEST_BASE_URL))
-            dataSource.getVersionInfo()
-            storage.storeServerVersion(TEST_VERSION)
        }
    }
-
-    @Test
-    fun `when tryBaseURL fails expect call to storage`() = runTest {
-        coEvery { storage.getServerVersion() } returns "serverVersion"
-        coEvery { storage.getBaseURL() } returns "baseUrl"
-        coEvery { dataSource.getVersionInfo() } throws IOException()
-        subject.tryBaseURL(TEST_BASE_URL)
-        coVerify {
-            storage.storeBaseURL(eq(TEST_BASE_URL))
-            dataSource.getVersionInfo()
-            storage.storeBaseURL(eq("baseUrl"), eq("serverVersion"))
-        }
-    }
-
-    @Test
-    fun `when storage is empty expect getVersion to call data source`() = runTest {
-        coEvery { storage.getServerVersion() } returns null
-        coEvery { storage.getBaseURL() } returns TEST_BASE_URL
-        coEvery { dataSource.getVersionInfo() } returns VERSION_INFO_V0
-        subject.getVersion()
-        coVerify { dataSource.getVersionInfo() }
-    }
-
-    @Test
-    fun `when storage is empty and data source has value expect getVersion to save it`() = runTest {
-        coEvery { storage.getServerVersion() } returns null
-        coEvery { storage.getBaseURL() } returns TEST_BASE_URL
-        coEvery { dataSource.getVersionInfo() } returns VersionInfo(TEST_VERSION)
-        subject.getVersion()
-        coVerify { storage.storeServerVersion(TEST_VERSION) }
-    }
-
-    @Test
-    fun `when data source has invalid value expect getVersion to return v1`() = runTest {
-        coEvery { storage.getServerVersion() } returns null
-        coEvery { storage.getBaseURL() } returns TEST_BASE_URL
-        coEvery { dataSource.getVersionInfo() } returns VersionInfo("v2.0.0")
-        assertThat(subject.getVersion()).isEqualTo(ServerVersion.V1)
-    }
-
-    @Test
-    fun `when data source has invalid value expect getVersion to save value`() = runTest {
-        coEvery { storage.getServerVersion() } returns null
-        coEvery { storage.getBaseURL() } returns TEST_BASE_URL
-        coEvery { dataSource.getVersionInfo() } returns VersionInfo("v2.0.0")
-        subject.getVersion()
-        coVerify { storage.storeServerVersion("v2.0.0") }
-    }
-
-    @Test
-    fun `when storage has value expect getVersion to not get URL`() = runTest {
-        coEvery { storage.getServerVersion() } returns TEST_VERSION
-        subject.getVersion()
-        coVerify(inverse = true) { storage.getBaseURL() }
-    }
-
-    @Test
-    fun `when storage has value expect getVersion to not call data source`() = runTest {
-        coEvery { storage.getServerVersion() } returns TEST_VERSION
-        subject.getVersion()
-        coVerify(inverse = true) { dataSource.getVersionInfo() }
-    }
-
-    @Test
-    fun `when storage has v0 value expect getVersion to return parsed`() = runTest {
-        coEvery { storage.getServerVersion() } returns "v0.5.6"
-        assertThat(subject.getVersion()).isEqualTo(ServerVersion.V0)
-    }
-
-    @Test
-    fun `when storage has v1 value expect getVersion to return parsed`() = runTest {
-        coEvery { storage.getServerVersion() } returns "v1.0.0-beta05"
-        assertThat(subject.getVersion()).isEqualTo(ServerVersion.V1)
-    }
-
-    @Test
-    fun `when data source has valid v0 value expect getVersion to return it`() = runTest {
-        coEvery { storage.getServerVersion() } returns null
-        coEvery { storage.getBaseURL() } returns TEST_BASE_URL
-        coEvery { dataSource.getVersionInfo() } returns VersionInfo("v0.5.6")
-        assertThat(subject.getVersion()).isEqualTo(ServerVersion.V0)
-    }
-
-    @Test
-    fun `when data source has valid v1 value expect getVersion to return it`() = runTest {
-        coEvery { storage.getServerVersion() } returns null
-        coEvery { storage.getBaseURL() } returns TEST_BASE_URL
-        coEvery { dataSource.getVersionInfo() } returns VersionInfo("v1.0.0-beta05")
-        assertThat(subject.getVersion()).isEqualTo(ServerVersion.V1)
-    }
 }
--- a/app/src/test/java/gq/kirmanak/mealient/data/baseurl/ServerInfoStorageTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/baseurl/ServerInfoStorageTest.kt
@@ -5,18 +5,15 @@ import com.google.common.truth.Truth.assertThat
 import gq.kirmanak.mealient.data.baseurl.impl.ServerInfoStorageImpl
 import gq.kirmanak.mealient.data.storage.PreferencesStorage
 import gq.kirmanak.mealient.test.AuthImplTestData.TEST_BASE_URL
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_VERSION
 import gq.kirmanak.mealient.test.BaseUnitTest
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class ServerInfoStorageTest : BaseUnitTest() {

    @MockK(relaxUnitFun = true)
@@ -25,14 +22,12 @@ class ServerInfoStorageTest : BaseUnitTest() {
    lateinit var subject: ServerInfoStorage

    private val baseUrlKey = stringPreferencesKey("baseUrlKey")
-    private val serverVersionKey = stringPreferencesKey("serverVersionKey")

    @Before
    override fun setUp() {
        super.setUp()
        subject = ServerInfoStorageImpl(preferencesStorage)
        every { preferencesStorage.baseUrlKey } returns baseUrlKey
-        every { preferencesStorage.serverVersionKey } returns serverVersionKey
    }

    @Test
@@ -49,30 +44,11 @@ class ServerInfoStorageTest : BaseUnitTest() {

    @Test
    fun `when storeBaseURL expect call to preferences storage`() = runTest {
-        subject.storeBaseURL(TEST_BASE_URL, TEST_VERSION)
+        subject.storeBaseURL(TEST_BASE_URL)
        coVerify {
            preferencesStorage.storeValues(
                eq(Pair(baseUrlKey, TEST_BASE_URL)),
-                eq(Pair(serverVersionKey, TEST_VERSION)),
            )
        }
    }
-
-    @Test
-    fun `when preference storage is empty expect getServerVersion return null`() = runTest {
-        coEvery { preferencesStorage.getValue(eq(serverVersionKey)) } returns null
-        assertThat(subject.getServerVersion()).isNull()
-    }
-
-    @Test
-    fun `when preference storage has value expect getServerVersion return value`() = runTest {
-        coEvery { preferencesStorage.getValue(eq(serverVersionKey)) } returns TEST_VERSION
-        assertThat(subject.getServerVersion()).isEqualTo(TEST_VERSION)
-    }
-
-    @Test
-    fun `when storeServerVersion then calls preferences storage`() = runTest {
-        subject.storeServerVersion(TEST_VERSION)
-        coVerify { preferencesStorage.storeValues(eq(Pair(serverVersionKey, TEST_VERSION))) }
-    }
 }
--- a/app/src/test/java/gq/kirmanak/mealient/data/disclaimer/DisclaimerStorageImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/disclaimer/DisclaimerStorageImplTest.kt
@@ -3,12 +3,10 @@ package gq.kirmanak.mealient.data.disclaimer
 import com.google.common.truth.Truth.assertThat
 import dagger.hilt.android.testing.HiltAndroidTest
 import gq.kirmanak.mealient.test.HiltRobolectricTest
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import javax.inject.Inject

-@OptIn(ExperimentalCoroutinesApi::class)
@HiltAndroidTest
 class DisclaimerStorageImplTest : HiltRobolectricTest() {

--- a/app/src/test/java/gq/kirmanak/mealient/data/migration/From24AuthMigrationExecutorTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/migration/From24AuthMigrationExecutorTest.kt
@@ -12,14 +12,12 @@ import io.mockk.MockKAnnotations
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
 import java.io.IOException
 import javax.inject.Inject

-@OptIn(ExperimentalCoroutinesApi::class)
@HiltAndroidTest
 class From24AuthMigrationExecutorTest : HiltRobolectricTest() {

--- a/app/src/test/java/gq/kirmanak/mealient/data/migration/MigrationDetectorImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/migration/MigrationDetectorImplTest.kt
@@ -9,11 +9,9 @@ import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
 import io.mockk.mockk
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class MigrationDetectorImplTest : BaseUnitTest() {

    @MockK(relaxUnitFun = true)
--- a/app/src/test/java/gq/kirmanak/mealient/data/network/MealieDataSourceWrapperTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/network/MealieDataSourceWrapperTest.kt
@@ -2,50 +2,35 @@ package gq.kirmanak.mealient.data.network

 import com.google.common.truth.Truth.assertThat
 import gq.kirmanak.mealient.data.auth.AuthRepo
-import gq.kirmanak.mealient.data.baseurl.ServerInfoRepo
-import gq.kirmanak.mealient.datasource.v0.MealieDataSourceV0
-import gq.kirmanak.mealient.datasource.v1.MealieDataSourceV1
+import gq.kirmanak.mealient.datasource.MealieDataSource
 import gq.kirmanak.mealient.datasource_test.PORRIDGE_ADD_RECIPE_INFO
-import gq.kirmanak.mealient.datasource_test.PORRIDGE_ADD_RECIPE_REQUEST_V0
-import gq.kirmanak.mealient.datasource_test.PORRIDGE_CREATE_RECIPE_REQUEST_V1
-import gq.kirmanak.mealient.datasource_test.PORRIDGE_FULL_RECIPE_INFO
-import gq.kirmanak.mealient.datasource_test.PORRIDGE_RECIPE_RESPONSE_V1
-import gq.kirmanak.mealient.datasource_test.PORRIDGE_RECIPE_SUMMARY_RESPONSE_V0
-import gq.kirmanak.mealient.datasource_test.PORRIDGE_RECIPE_SUMMARY_RESPONSE_V1
-import gq.kirmanak.mealient.datasource_test.PORRIDGE_UPDATE_RECIPE_REQUEST_V1
-import gq.kirmanak.mealient.datasource_test.RECIPE_SUMMARY_PORRIDGE_V0
-import gq.kirmanak.mealient.datasource_test.RECIPE_SUMMARY_PORRIDGE_V1
+import gq.kirmanak.mealient.datasource_test.PORRIDGE_CREATE_RECIPE_REQUEST
+import gq.kirmanak.mealient.datasource_test.PORRIDGE_RECIPE_RESPONSE
+import gq.kirmanak.mealient.datasource_test.PORRIDGE_RECIPE_SUMMARY_RESPONSE
+import gq.kirmanak.mealient.datasource_test.PORRIDGE_UPDATE_RECIPE_REQUEST
+import gq.kirmanak.mealient.datasource_test.RECIPE_SUMMARY_PORRIDGE
 import gq.kirmanak.mealient.model_mapper.ModelMapper
 import gq.kirmanak.mealient.model_mapper.ModelMapperImpl
 import gq.kirmanak.mealient.test.AuthImplTestData.FAVORITE_RECIPES_LIST
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_AUTH_HEADER
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_SERVER_VERSION_V0
-import gq.kirmanak.mealient.test.AuthImplTestData.TEST_SERVER_VERSION_V1
-import gq.kirmanak.mealient.test.AuthImplTestData.USER_INFO_V0
-import gq.kirmanak.mealient.test.AuthImplTestData.USER_INFO_V1
+import gq.kirmanak.mealient.test.AuthImplTestData.TEST_TOKEN
+import gq.kirmanak.mealient.test.AuthImplTestData.USER_INFO
 import gq.kirmanak.mealient.test.BaseUnitTest
-import io.mockk.*
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.coVerifySequence
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
 import java.io.IOException

-@OptIn(ExperimentalCoroutinesApi::class)
 class MealieDataSourceWrapperTest : BaseUnitTest() {

-    @MockK
-    lateinit var serverInfoRepo: ServerInfoRepo
-
    @MockK(relaxUnitFun = true)
    lateinit var authRepo: AuthRepo

    @MockK(relaxUnitFun = true)
-    lateinit var v0Source: MealieDataSourceV0
-
-    @MockK(relaxUnitFun = true)
-    lateinit var v1Source: MealieDataSourceV1
+    lateinit var dataSource: MealieDataSource

    private val modelMapper: ModelMapper = ModelMapperImpl()

@@ -54,111 +39,68 @@ class MealieDataSourceWrapperTest : BaseUnitTest() {
    @Before
    override fun setUp() {
        super.setUp()
-        subject = MealieDataSourceWrapper(serverInfoRepo, v0Source, v1Source, modelMapper)
-        coEvery { v0Source.requestUserInfo() } returns USER_INFO_V0
-        coEvery { v1Source.requestUserInfo() } returns USER_INFO_V1
+        subject = MealieDataSourceWrapper(dataSource, modelMapper)
+        coEvery { dataSource.requestUserInfo() } returns USER_INFO
    }

    @Test
-    fun `when server version v1 expect requestRecipeInfo to call v1`() = runTest {
+    fun `when requestRecipeInfo expect a valid network call`() = runTest {
        val slug = "porridge"
-        coEvery { v1Source.requestRecipeInfo(eq(slug)) } returns PORRIDGE_RECIPE_RESPONSE_V1
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V1
-        coEvery { authRepo.getAuthHeader() } returns TEST_AUTH_HEADER
+        coEvery { dataSource.requestRecipeInfo(eq(slug)) } returns PORRIDGE_RECIPE_RESPONSE
+        coEvery { authRepo.getAuthToken() } returns TEST_TOKEN

-        val actual = subject.requestRecipeInfo(slug)
+        val actual = subject.requestRecipe(slug)

-        coVerify { v1Source.requestRecipeInfo(eq(slug)) }
+        coVerify { dataSource.requestRecipeInfo(eq(slug)) }

-        assertThat(actual).isEqualTo(PORRIDGE_FULL_RECIPE_INFO)
+        assertThat(actual).isEqualTo(PORRIDGE_RECIPE_RESPONSE)
    }

    @Test
-    fun `when server version v1 expect requestRecipes to call v1`() = runTest {
+    fun `when requestRecipes expect valid network request`() = runTest {
        coEvery {
-            v1Source.requestRecipes(any(), any())
-        } returns listOf(PORRIDGE_RECIPE_SUMMARY_RESPONSE_V1)
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V1
-        coEvery { authRepo.getAuthHeader() } returns TEST_AUTH_HEADER
+            dataSource.requestRecipes(any(), any())
+        } returns listOf(PORRIDGE_RECIPE_SUMMARY_RESPONSE)
+        coEvery { authRepo.getAuthToken() } returns TEST_TOKEN

        val actual = subject.requestRecipes(40, 10)

        val page = 5 // 0-9 (1), 10-19 (2), 20-29 (3), 30-39 (4), 40-49 (5)
        val perPage = 10
        coVerify {
-            v1Source.requestRecipes(eq(page), eq(perPage))
+            dataSource.requestRecipes(eq(page), eq(perPage))
        }

-        assertThat(actual).isEqualTo(listOf(RECIPE_SUMMARY_PORRIDGE_V1))
-    }
-
-    @Test
-    fun `when server version v0 expect requestRecipes to call v0`() = runTest {
-        coEvery {
-            v0Source.requestRecipes(any(), any())
-        } returns listOf(PORRIDGE_RECIPE_SUMMARY_RESPONSE_V0)
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
-        coEvery { authRepo.getAuthHeader() } returns TEST_AUTH_HEADER
-
-        val start = 40
-        val limit = 10
-        val actual = subject.requestRecipes(start, limit)
-
-        coVerify {
-            v0Source.requestRecipes(eq(start), eq(limit))
-        }
-
-        assertThat(actual).isEqualTo(listOf(RECIPE_SUMMARY_PORRIDGE_V0))
+        assertThat(actual).isEqualTo(listOf(RECIPE_SUMMARY_PORRIDGE))
    }

    @Test(expected = IOException::class)
-    fun `when request fails expect addRecipe to rethrow`() = runTest {
-        coEvery { v0Source.addRecipe(any()) } throws IOException()
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
-        coEvery { authRepo.getAuthHeader() } returns TEST_AUTH_HEADER
+    fun `when request fails expect createRecipe to rethrow`() = runTest {
+        coEvery { dataSource.createRecipe(any()) } throws IOException()
+        coEvery { authRepo.getAuthToken() } returns TEST_TOKEN
        subject.addRecipe(PORRIDGE_ADD_RECIPE_INFO)
    }

    @Test
-    fun `when server version v0 expect addRecipe to call v0`() = runTest {
+    fun `when create recipe expect createRecipe to call in sequence`() = runTest {
        val slug = "porridge"

-        coEvery { v0Source.addRecipe(any()) } returns slug
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
-        coEvery { authRepo.getAuthHeader() } returns TEST_AUTH_HEADER
-
-        val actual = subject.addRecipe(PORRIDGE_ADD_RECIPE_INFO)
-
-        coVerify {
-            v0Source.addRecipe(
-                eq(PORRIDGE_ADD_RECIPE_REQUEST_V0),
-            )
-        }
-
-        assertThat(actual).isEqualTo(slug)
-    }
-
-    @Test
-    fun `when server version v1 expect addRecipe to call v1`() = runTest {
-        val slug = "porridge"
-
-        coEvery { v1Source.createRecipe(any()) } returns slug
+        coEvery { dataSource.createRecipe(any()) } returns slug
        coEvery {
-            v1Source.updateRecipe(any(), any())
-        } returns PORRIDGE_RECIPE_RESPONSE_V1
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V1
-        coEvery { authRepo.getAuthHeader() } returns TEST_AUTH_HEADER
+            dataSource.updateRecipe(any(), any())
+        } returns PORRIDGE_RECIPE_RESPONSE
+        coEvery { authRepo.getAuthToken() } returns TEST_TOKEN

        val actual = subject.addRecipe(PORRIDGE_ADD_RECIPE_INFO)

        coVerifySequence {
-            v1Source.createRecipe(
-                eq(PORRIDGE_CREATE_RECIPE_REQUEST_V1),
+            dataSource.createRecipe(
+                eq(PORRIDGE_CREATE_RECIPE_REQUEST),
            )

-            v1Source.updateRecipe(
+            dataSource.updateRecipe(
                eq(slug),
-                eq(PORRIDGE_UPDATE_RECIPE_REQUEST_V1),
+                eq(PORRIDGE_UPDATE_RECIPE_REQUEST),
            )
        }

@@ -166,68 +108,31 @@ class MealieDataSourceWrapperTest : BaseUnitTest() {
    }

    @Test
-    fun `when remove favorite recipe info with v0 expect correct sequence`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
+    fun `when remove favorite recipe info expect correct sequence`() = runTest {
        subject.updateIsRecipeFavorite(recipeSlug = "cake", isFavorite = false)
        coVerify {
-            v0Source.requestUserInfo()
-            v0Source.removeFavoriteRecipe(eq(3), eq("cake"))
+            dataSource.requestUserInfo()
+            dataSource.removeFavoriteRecipe(eq("userId"), eq("cake"))
        }
    }

    @Test
-    fun `when remove favorite recipe info with v1 expect correct sequence`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V1
-        subject.updateIsRecipeFavorite(recipeSlug = "cake", isFavorite = false)
-        coVerify {
-            v1Source.requestUserInfo()
-            v1Source.removeFavoriteRecipe(eq("userId"), eq("cake"))
-        }
-    }
-
-    @Test
-    fun `when add favorite recipe info with v0 expect correct sequence`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
+    fun `when add favorite recipe info expect correct sequence`() = runTest {
        subject.updateIsRecipeFavorite(recipeSlug = "cake", isFavorite = true)
        coVerify {
-            v0Source.requestUserInfo()
-            v0Source.addFavoriteRecipe(eq(3), eq("cake"))
+            dataSource.requestUserInfo()
+            dataSource.addFavoriteRecipe(eq("userId"), eq("cake"))
        }
    }

    @Test
-    fun `when add favorite recipe info with v1 expect correct sequence`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V1
-        subject.updateIsRecipeFavorite(recipeSlug = "cake", isFavorite = true)
-        coVerify {
-            v1Source.requestUserInfo()
-            v1Source.addFavoriteRecipe(eq("userId"), eq("cake"))
-        }
-    }
-
-    @Test
-    fun `when get favorite recipes with v1 expect correct call`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V1
+    fun `when get favorite recipes expect correct call`() = runTest {
        subject.getFavoriteRecipes()
-        coVerify { v1Source.requestUserInfo() }
+        coVerify { dataSource.requestUserInfo() }
    }

    @Test
-    fun `when get favorite recipes with v0 expect correct call`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
-        subject.getFavoriteRecipes()
-        coVerify { v0Source.requestUserInfo() }
-    }
-
-    @Test
-    fun `when get favorite recipes with v1 expect correct result`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V1
-        assertThat(subject.getFavoriteRecipes()).isEqualTo(FAVORITE_RECIPES_LIST)
-    }
-
-    @Test
-    fun `when get favorite recipes with v0 expect correct result`() = runTest {
-        coEvery { serverInfoRepo.getVersion() } returns TEST_SERVER_VERSION_V0
+    fun `when get favorite recipes expect correct result`() = runTest {
        assertThat(subject.getFavoriteRecipes()).isEqualTo(FAVORITE_RECIPES_LIST)
    }
 }
--- a/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipeImageUrlProviderImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipeImageUrlProviderImplTest.kt
@@ -1,27 +1,26 @@
 package gq.kirmanak.mealient.data.recipes.impl

 import com.google.common.truth.Truth.assertThat
-import gq.kirmanak.mealient.data.baseurl.ServerInfoRepo
-import gq.kirmanak.mealient.test.BaseUnitTest
-import io.mockk.coEvery
-import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
+import dagger.hilt.android.testing.HiltAndroidTest
+import gq.kirmanak.mealient.data.baseurl.ServerInfoStorage
+import gq.kirmanak.mealient.test.HiltRobolectricTest
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
+import javax.inject.Inject

-@OptIn(ExperimentalCoroutinesApi::class)
-class RecipeImageUrlProviderImplTest : BaseUnitTest() {
+@HiltAndroidTest
+class RecipeImageUrlProviderImplTest : HiltRobolectricTest() {

+    @Inject
    lateinit var subject: RecipeImageUrlProvider

-    @MockK
-    lateinit var serverInfoRepo: ServerInfoRepo
+    @Inject
+    lateinit var serverInfoStorage: ServerInfoStorage

    @Before
-    override fun setUp() {
-        super.setUp()
-        subject = RecipeImageUrlProviderImpl(serverInfoRepo, logger)
+    fun setUp() {
        prepareBaseURL("https://google.com/")
    }

@@ -76,7 +75,7 @@ class RecipeImageUrlProviderImplTest : BaseUnitTest() {
        assertThat(actual).isNull()
    }

-    private fun prepareBaseURL(baseURL: String?) {
-        coEvery { serverInfoRepo.getUrl() } returns baseURL
+    private fun prepareBaseURL(baseURL: String?) = runBlocking {
+        serverInfoStorage.storeBaseURL(baseURL)
    }
 }
--- a/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipePagingSourceFactoryImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipePagingSourceFactoryImplTest.kt
@@ -9,13 +9,11 @@ import gq.kirmanak.mealient.database.TEST_RECIPE_SUMMARY_ENTITIES
 import gq.kirmanak.mealient.database.recipe.RecipeStorage
 import gq.kirmanak.mealient.database.recipe.entity.RecipeSummaryEntity
 import gq.kirmanak.mealient.test.HiltRobolectricTest
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import javax.inject.Inject

@HiltAndroidTest
-@OptIn(ExperimentalCoroutinesApi::class)
 class RecipePagingSourceFactoryImplTest : HiltRobolectricTest() {

    @Inject
--- a/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipeRepoTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipeRepoTest.kt
@@ -13,7 +13,7 @@ import gq.kirmanak.mealient.database.FULL_CAKE_INFO_ENTITY
 import gq.kirmanak.mealient.database.MIX_CAKE_RECIPE_INSTRUCTION_ENTITY
 import gq.kirmanak.mealient.database.recipe.RecipeStorage
 import gq.kirmanak.mealient.datasource.NetworkError.Unauthorized
-import gq.kirmanak.mealient.datasource_test.CAKE_FULL_RECIPE_INFO
+import gq.kirmanak.mealient.datasource_test.CAKE_RECIPE_RESPONSE
 import gq.kirmanak.mealient.model_mapper.ModelMapper
 import gq.kirmanak.mealient.model_mapper.ModelMapperImpl
 import gq.kirmanak.mealient.test.BaseUnitTest
@@ -22,13 +22,11 @@ import io.mockk.coVerify
 import io.mockk.coVerifyOrder
 import io.mockk.impl.annotations.MockK
 import io.mockk.verify
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
 import java.io.IOException

-@OptIn(ExperimentalCoroutinesApi::class)
 class RecipeRepoTest : BaseUnitTest() {

    @MockK(relaxUnitFun = true)
@@ -69,7 +67,7 @@ class RecipeRepoTest : BaseUnitTest() {

    @Test
    fun `when refreshRecipeInfo expect call to storage`() = runTest {
-        coEvery { dataSource.requestRecipeInfo(eq("cake")) } returns CAKE_FULL_RECIPE_INFO
+        coEvery { dataSource.requestRecipe(eq("cake")) } returns CAKE_RECIPE_RESPONSE
        subject.refreshRecipeInfo("cake")
        coVerify {
            storage.saveRecipeInfo(
--- a/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipesRemoteMediatorTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/recipes/impl/RecipesRemoteMediatorTest.kt
@@ -16,13 +16,11 @@ import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.impl.annotations.MockK
 import io.mockk.verify
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
 import java.io.IOException

-@ExperimentalCoroutinesApi
@OptIn(ExperimentalPagingApi::class)
 class RecipesRemoteMediatorTest : BaseUnitTest() {

--- a/app/src/test/java/gq/kirmanak/mealient/data/share/ShareRecipeRepoImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/share/ShareRecipeRepoImplTest.kt
@@ -1,15 +1,13 @@
 package gq.kirmanak.mealient.data.share

-import gq.kirmanak.mealient.datasource.models.ParseRecipeURLInfo
+import gq.kirmanak.mealient.datasource.models.ParseRecipeURLRequest
 import gq.kirmanak.mealient.test.BaseUnitTest
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class ShareRecipeRepoImplTest : BaseUnitTest() {


@@ -32,7 +30,7 @@ class ShareRecipeRepoImplTest : BaseUnitTest() {
    @Test
    fun `when url is correct expect saveRecipeByURL saves it`() = runTest {
        subject.saveRecipeByURL("https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie/")
-        val expected = ParseRecipeURLInfo(
+        val expected = ParseRecipeURLRequest(
            url = "https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie/",
            includeTags = true
        )
@@ -42,7 +40,7 @@ class ShareRecipeRepoImplTest : BaseUnitTest() {
    @Test
    fun `when url has prefix expect saveRecipeByURL removes it`() = runTest {
        subject.saveRecipeByURL("My favorite recipe: https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie/")
-        val expected = ParseRecipeURLInfo(
+        val expected = ParseRecipeURLRequest(
            url = "https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie/",
            includeTags = true
        )
@@ -52,7 +50,7 @@ class ShareRecipeRepoImplTest : BaseUnitTest() {
    @Test
    fun `when url has suffix expect saveRecipeByURL removes it`() = runTest {
        subject.saveRecipeByURL("https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie/ is my favorite recipe")
-        val expected = ParseRecipeURLInfo(
+        val expected = ParseRecipeURLRequest(
            url = "https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie",
            includeTags = true
        )
@@ -62,7 +60,7 @@ class ShareRecipeRepoImplTest : BaseUnitTest() {
    @Test
    fun `when url has prefix and suffix expect saveRecipeByURL removes them`() = runTest {
        subject.saveRecipeByURL("Actually, https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie/ is my favorite recipe")
-        val expected = ParseRecipeURLInfo(
+        val expected = ParseRecipeURLRequest(
            url = "https://www.allrecipes.com/recipe/215447/dads-leftover-turkey-pot-pie",
            includeTags = true
        )
--- a/app/src/test/java/gq/kirmanak/mealient/data/storage/PreferencesStorageImplTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/data/storage/PreferencesStorageImplTest.kt
@@ -3,13 +3,11 @@ package gq.kirmanak.mealient.data.storage
 import com.google.common.truth.Truth.assertThat
 import dagger.hilt.android.testing.HiltAndroidTest
 import gq.kirmanak.mealient.test.HiltRobolectricTest
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import javax.inject.Inject

-@OptIn(ExperimentalCoroutinesApi::class)
@HiltAndroidTest
 class PreferencesStorageImplTest : HiltRobolectricTest() {

--- a/app/src/test/java/gq/kirmanak/mealient/test/AuthImplTestData.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/test/AuthImplTestData.kt
@@ -1,22 +1,14 @@
 package gq.kirmanak.mealient.test

-import gq.kirmanak.mealient.data.baseurl.ServerVersion
-import gq.kirmanak.mealient.datasource.v0.models.GetUserInfoResponseV0
-import gq.kirmanak.mealient.datasource.v1.models.GetUserInfoResponseV1
+import gq.kirmanak.mealient.datasource.models.GetUserInfoResponse

 object AuthImplTestData {
    const val TEST_USERNAME = "TEST_USERNAME"
    const val TEST_PASSWORD = "TEST_PASSWORD"
    const val TEST_BASE_URL = "https://example.com"
    const val TEST_TOKEN = "TEST_TOKEN"
-    const val TEST_AUTH_HEADER = "Bearer TEST_TOKEN"
    const val TEST_API_TOKEN = "TEST_API_TOKEN"
-    const val TEST_API_AUTH_HEADER = "Bearer TEST_API_TOKEN"
-    const val TEST_VERSION = "v0.5.6"
-    val TEST_SERVER_VERSION_V0 = ServerVersion.V0
-    val TEST_SERVER_VERSION_V1 = ServerVersion.V1

    val FAVORITE_RECIPES_LIST = listOf("cake", "porridge")
-    val USER_INFO_V1 = GetUserInfoResponseV1("userId", FAVORITE_RECIPES_LIST)
-    val USER_INFO_V0 = GetUserInfoResponseV0(3, FAVORITE_RECIPES_LIST)
+    val USER_INFO = GetUserInfoResponse("userId", FAVORITE_RECIPES_LIST)
 }
--- a/app/src/test/java/gq/kirmanak/mealient/ui/activity/MainActivityViewModelTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/ui/activity/MainActivityViewModelTest.kt
@@ -45,7 +45,6 @@ class MainActivityViewModelTest : BaseUnitTest() {
        every { activityUiStateController.getUiStateFlow() } returns MutableStateFlow(
            ActivityUiState()
        )
-        coEvery { serverInfoRepo.versionUpdates() } returns emptyFlow()
        subject = MainActivityViewModel(
            authRepo = authRepo,
            logger = logger,
--- a/app/src/test/java/gq/kirmanak/mealient/ui/add/AddRecipeViewModelTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/ui/add/AddRecipeViewModelTest.kt
@@ -7,7 +7,6 @@ import gq.kirmanak.mealient.test.BaseUnitTest
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.flowOf
@@ -16,7 +15,6 @@ import kotlinx.coroutines.withTimeoutOrNull
 import org.junit.Before
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class AddRecipeViewModelTest : BaseUnitTest() {

    @MockK(relaxUnitFun = true)
--- a/app/src/test/java/gq/kirmanak/mealient/ui/recipes/info/RecipeInfoViewModelTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/ui/recipes/info/RecipeInfoViewModelTest.kt
@@ -7,12 +7,10 @@ import gq.kirmanak.mealient.database.FULL_CAKE_INFO_ENTITY
 import gq.kirmanak.mealient.test.BaseUnitTest
 import io.mockk.coEvery
 import io.mockk.impl.annotations.MockK
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class RecipeInfoViewModelTest : BaseUnitTest() {

    @MockK
--- a/app/src/test/java/gq/kirmanak/mealient/ui/share/ShareRecipeViewModelTest.kt
+++ b/app/src/test/java/gq/kirmanak/mealient/ui/share/ShareRecipeViewModelTest.kt
@@ -9,7 +9,6 @@ import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.impl.annotations.MockK
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.flow.toList
@@ -17,7 +16,6 @@ import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test

-@OptIn(ExperimentalCoroutinesApi::class)
 class ShareRecipeViewModelTest : BaseUnitTest() {

    @MockK(relaxUnitFun = true)