1 /*
2  * Copyright (C) 2023 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.healthconnect.controller.tests.migration.api
18 
19 import android.health.connect.HealthConnectDataState
20 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_ALLOWED_ERROR
21 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_ALLOWED_MIGRATOR_DISABLED
22 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_ALLOWED_NOT_STARTED
23 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_ALLOWED_PAUSED
24 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_APP_UPGRADE_REQUIRED
25 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_COMPLETE
26 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_COMPLETE_IDLE
27 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_IDLE
28 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_IN_PROGRESS
29 import android.health.connect.migration.HealthConnectMigrationUiState.MIGRATION_UI_STATE_MODULE_UPGRADE_REQUIRED
30 import com.android.healthconnect.controller.migration.api.LoadMigrationRestoreStateUseCase
31 import com.android.healthconnect.controller.migration.api.MigrationRestoreState
32 import com.android.healthconnect.controller.migration.api.MigrationRestoreState.DataRestoreUiError
33 import com.android.healthconnect.controller.migration.api.MigrationRestoreState.DataRestoreUiState
34 import com.android.healthconnect.controller.migration.api.MigrationRestoreState.MigrationUiState
35 import com.android.healthconnect.controller.tests.utils.di.FakeHealthMigrationManager
36 import com.google.common.truth.Truth.assertThat
37 import kotlinx.coroutines.ExperimentalCoroutinesApi
38 import kotlinx.coroutines.test.runTest
39 import org.junit.Test
40 
41 @OptIn(ExperimentalCoroutinesApi::class)
42 class LoadMigrationRestoreStateUseCaseTest {
43 
44     private val migrationManager = FakeHealthMigrationManager()
45 
46     @Test
<lambda>null47     fun invoke_migrationStateIdle_mapsStateToIdle() = runTest {
48         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
49         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_IDLE)
50 
51         assertThat(useCase.invoke())
52             .isEqualTo(
53                 MigrationRestoreState(
54                     migrationUiState = MigrationUiState.IDLE,
55                     dataRestoreState = DataRestoreUiState.IDLE,
56                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
57     }
58 
59     @Test
invoke_migrationStateAllowedMigratorDisabled_mapsStateToAllowedMigratorDisablednull60     fun invoke_migrationStateAllowedMigratorDisabled_mapsStateToAllowedMigratorDisabled() =
61         runTest {
62             val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
63             migrationManager.setMigrationUiState(MIGRATION_UI_STATE_ALLOWED_MIGRATOR_DISABLED)
64 
65             assertThat(useCase.invoke())
66                 .isEqualTo(
67                     MigrationRestoreState(
68                         migrationUiState = MigrationUiState.ALLOWED_MIGRATOR_DISABLED,
69                         dataRestoreState = DataRestoreUiState.IDLE,
70                         dataRestoreError = DataRestoreUiError.ERROR_NONE))
71         }
72 
73     @Test
<lambda>null74     fun invoke_migrationStateAllowedNotStarted_mapsAllowedNotStarted() = runTest {
75         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
76         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_ALLOWED_NOT_STARTED)
77 
78         assertThat(useCase.invoke())
79             .isEqualTo(
80                 MigrationRestoreState(
81                     migrationUiState = MigrationUiState.ALLOWED_NOT_STARTED,
82                     dataRestoreState = DataRestoreUiState.IDLE,
83                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
84     }
85 
86     @Test
<lambda>null87     fun invoke_migrationStateAllowedPaused_mapsStateToAllowedPaused() = runTest {
88         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
89         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_ALLOWED_PAUSED)
90 
91         assertThat(useCase.invoke())
92             .isEqualTo(
93                 MigrationRestoreState(
94                     migrationUiState = MigrationUiState.ALLOWED_PAUSED,
95                     dataRestoreState = DataRestoreUiState.IDLE,
96                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
97     }
98 
99     @Test
<lambda>null100     fun invoke_migrationStateIdleAllowedError_mapsStateToAllowedError() = runTest {
101         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
102         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_ALLOWED_ERROR)
103 
104         assertThat(useCase.invoke())
105             .isEqualTo(
106                 MigrationRestoreState(
107                     migrationUiState = MigrationUiState.ALLOWED_ERROR,
108                     dataRestoreState = DataRestoreUiState.IDLE,
109                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
110     }
111 
112     @Test
<lambda>null113     fun invoke_migrationStateInProgress_mapsStateToInProgress() = runTest {
114         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
115         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_IN_PROGRESS)
116 
117         assertThat(useCase.invoke())
118             .isEqualTo(
119                 MigrationRestoreState(
120                     migrationUiState = MigrationUiState.IN_PROGRESS,
121                     dataRestoreState = DataRestoreUiState.IDLE,
122                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
123     }
124 
125     @Test
<lambda>null126     fun invoke_migrationStateAppUpgradeRequired_mapsStateToAppUpgradeRequired() = runTest {
127         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
128         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_APP_UPGRADE_REQUIRED)
129 
130         assertThat(useCase.invoke())
131             .isEqualTo(
132                 MigrationRestoreState(
133                     migrationUiState = MigrationUiState.APP_UPGRADE_REQUIRED,
134                     dataRestoreState = DataRestoreUiState.IDLE,
135                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
136     }
137 
138     @Test
invoke_migrationStateModuleUpgradeRequired_mapsStateToModuleUpgradeRequirednull139     fun invoke_migrationStateModuleUpgradeRequired_mapsStateToModuleUpgradeRequired() = runTest {
140         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
141         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_MODULE_UPGRADE_REQUIRED)
142 
143         assertThat(useCase.invoke())
144             .isEqualTo(
145                 MigrationRestoreState(
146                     migrationUiState = MigrationUiState.MODULE_UPGRADE_REQUIRED,
147                     dataRestoreState = DataRestoreUiState.IDLE,
148                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
149     }
150 
151     @Test
<lambda>null152     fun invoke_migrationStateComplete_mapsStateToComplete() = runTest {
153         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
154         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_COMPLETE)
155 
156         assertThat(useCase.invoke())
157             .isEqualTo(
158                 MigrationRestoreState(
159                     migrationUiState = MigrationUiState.COMPLETE,
160                     dataRestoreState = DataRestoreUiState.IDLE,
161                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
162     }
163 
164     @Test
<lambda>null165     fun invoke_migrationStateCompleteIdle_mapsStateToCompleteIdle() = runTest {
166         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
167         migrationManager.setMigrationUiState(MIGRATION_UI_STATE_COMPLETE_IDLE)
168 
169         assertThat(useCase.invoke())
170             .isEqualTo(
171                 MigrationRestoreState(
172                     migrationUiState = MigrationUiState.COMPLETE_IDLE,
173                     dataRestoreState = DataRestoreUiState.IDLE,
174                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
175     }
176 
177     @Test
<lambda>null178     fun invoke_dataRestoreStateIdle_mapsStateToIdle() = runTest {
179         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
180         migrationManager.setDataMigrationState(
181             HealthConnectDataState(
182                 HealthConnectDataState.RESTORE_STATE_IDLE,
183                 HealthConnectDataState.RESTORE_ERROR_NONE,
184                 HealthConnectDataState.MIGRATION_STATE_IDLE))
185         assertThat(useCase.invoke())
186             .isEqualTo(
187                 MigrationRestoreState(
188                     migrationUiState = MigrationUiState.IDLE,
189                     dataRestoreState = DataRestoreUiState.IDLE,
190                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
191     }
192 
193     @Test
<lambda>null194     fun invoke_dataRestoreStatePending_mapsStateToPending() = runTest {
195         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
196         migrationManager.setDataMigrationState(
197             HealthConnectDataState(
198                 HealthConnectDataState.RESTORE_STATE_PENDING,
199                 HealthConnectDataState.RESTORE_ERROR_NONE,
200                 HealthConnectDataState.MIGRATION_STATE_IDLE))
201         assertThat(useCase.invoke())
202             .isEqualTo(
203                 MigrationRestoreState(
204                     migrationUiState = MigrationUiState.IDLE,
205                     dataRestoreState = DataRestoreUiState.PENDING,
206                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
207     }
208 
209     @Test
<lambda>null210     fun invoke_dataRestoreStateInProgress_mapsStateToInProgress() = runTest {
211         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
212         migrationManager.setDataMigrationState(
213             HealthConnectDataState(
214                 HealthConnectDataState.RESTORE_STATE_IN_PROGRESS,
215                 HealthConnectDataState.RESTORE_ERROR_NONE,
216                 HealthConnectDataState.MIGRATION_STATE_IDLE))
217         assertThat(useCase.invoke())
218             .isEqualTo(
219                 MigrationRestoreState(
220                     migrationUiState = MigrationUiState.IDLE,
221                     dataRestoreState = DataRestoreUiState.IN_PROGRESS,
222                     dataRestoreError = DataRestoreUiError.ERROR_NONE))
223     }
224 
225     @Test
<lambda>null226     fun invoke_dataRestoreErrorUnknown_mapsStateToErrorUnknown() = runTest {
227         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
228         migrationManager.setDataMigrationState(
229             HealthConnectDataState(
230                 HealthConnectDataState.RESTORE_STATE_IDLE,
231                 HealthConnectDataState.RESTORE_ERROR_UNKNOWN,
232                 HealthConnectDataState.MIGRATION_STATE_IDLE))
233         assertThat(useCase.invoke())
234             .isEqualTo(
235                 MigrationRestoreState(
236                     migrationUiState = MigrationUiState.IDLE,
237                     dataRestoreState = DataRestoreUiState.IDLE,
238                     dataRestoreError = DataRestoreUiError.ERROR_UNKNOWN))
239     }
240 
241     @Test
<lambda>null242     fun invoke_dataRestoreErrorFetchingData_mapsStateToErrorFetchingData() = runTest {
243         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
244         migrationManager.setDataMigrationState(
245             HealthConnectDataState(
246                 HealthConnectDataState.RESTORE_STATE_IDLE,
247                 HealthConnectDataState.RESTORE_ERROR_FETCHING_DATA,
248                 HealthConnectDataState.MIGRATION_STATE_IDLE))
249         assertThat(useCase.invoke())
250             .isEqualTo(
251                 MigrationRestoreState(
252                     migrationUiState = MigrationUiState.IDLE,
253                     dataRestoreState = DataRestoreUiState.IDLE,
254                     dataRestoreError = DataRestoreUiError.ERROR_FETCHING_DATA))
255     }
256 
257     @Test
<lambda>null258     fun invoke_dataRestoreErrorVersionDiff_mapsStateToErrorVersionDiff() = runTest {
259         val useCase = LoadMigrationRestoreStateUseCase(migrationManager)
260         migrationManager.setDataMigrationState(
261             HealthConnectDataState(
262                 HealthConnectDataState.RESTORE_STATE_IDLE,
263                 HealthConnectDataState.RESTORE_ERROR_VERSION_DIFF,
264                 HealthConnectDataState.MIGRATION_STATE_IDLE))
265         assertThat(useCase.invoke())
266             .isEqualTo(
267                 MigrationRestoreState(
268                     migrationUiState = MigrationUiState.IDLE,
269                     dataRestoreState = DataRestoreUiState.IDLE,
270                     dataRestoreError = DataRestoreUiError.ERROR_VERSION_DIFF))
271     }
272 }
273