@@ -36,8 +36,8 @@ class DefaultTasksRepositoryTest {
36
36
private val task2 = Task (title = " Title2" , description = " Description2" )
37
37
private val task3 = Task (title = " Title3" , description = " Description3" )
38
38
private val newTask = Task (title = " Title new" , description = " Description new" )
39
- private val networkTasks = listOf (task1, task2).toNetworkModels ().sortedBy { it.id }
40
- private val localTasks = listOf (task3.toLocalModel ()).sortedBy { it.id }
39
+ private val networkTasks = listOf (task1, task2).toNetwork ().sortedBy { it.id }
40
+ private val localTasks = listOf (task3.toLocal ()).sortedBy { it.id }
41
41
42
42
private val newTasks = listOf (newTask).sortedBy { it.id }
43
43
private lateinit var tasksNetworkDataSource: FakeNetworkDataSource
@@ -81,7 +81,7 @@ class DefaultTasksRepositoryTest {
81
81
val initial = tasksRepository.getTasks(forceUpdate = true )
82
82
83
83
// Change the remote data source
84
- tasksNetworkDataSource.tasks = newTasks.toNetworkModels ().toMutableList()
84
+ tasksNetworkDataSource.tasks = newTasks.toNetwork ().toMutableList()
85
85
86
86
// Load the tasks again without forcing a refresh
87
87
val second = tasksRepository.getTasks()
@@ -97,21 +97,21 @@ class DefaultTasksRepositoryTest {
97
97
val tasks = tasksRepository.getTasks(true )
98
98
99
99
// Then tasks are loaded from the remote data source
100
- assertThat(tasks).isEqualTo(networkTasks.toExternalModels ())
100
+ assertThat(tasks).isEqualTo(networkTasks.toExternal ())
101
101
}
102
102
103
103
@Test
104
104
fun saveTask_savesToLocalAndRemote () = runTest {
105
105
// Make sure newTask is not in the remote or local datasources
106
- assertThat(tasksNetworkDataSource.tasks).doesNotContain(newTask.toNetworkModel ())
107
- assertThat(tasksLocalDataSource.tasks).doesNotContain(newTask.toLocalModel ())
106
+ assertThat(tasksNetworkDataSource.tasks).doesNotContain(newTask.toNetwork ())
107
+ assertThat(tasksLocalDataSource.tasks).doesNotContain(newTask.toLocal ())
108
108
109
109
// When a task is saved to the tasks repository
110
110
val newTask = tasksRepository.createTask(newTask.title, newTask.description)
111
111
112
112
// Then the remote and local sources are called
113
- assertThat(tasksNetworkDataSource.tasks).contains(newTask.toNetworkModel ())
114
- assertThat(tasksLocalDataSource.tasks?.contains(newTask.toLocalModel ()))
113
+ assertThat(tasksNetworkDataSource.tasks).contains(newTask.toNetwork ())
114
+ assertThat(tasksLocalDataSource.tasks?.contains(newTask.toLocal ()))
115
115
}
116
116
117
117
@Test
@@ -120,7 +120,7 @@ class DefaultTasksRepositoryTest {
120
120
val tasks = tasksRepository.getTasks()
121
121
122
122
// Set a different list of tasks in REMOTE
123
- tasksNetworkDataSource.tasks = newTasks.toNetworkModels ().toMutableList()
123
+ tasksNetworkDataSource.tasks = newTasks.toNetwork ().toMutableList()
124
124
125
125
// But if tasks are cached, subsequent calls load from cache
126
126
val cachedTasks = tasksRepository.getTasks()
@@ -151,7 +151,7 @@ class DefaultTasksRepositoryTest {
151
151
tasksNetworkDataSource.tasks = null
152
152
153
153
// The repository fetches from the local source
154
- assertThat(tasksRepository.getTasks()).isEqualTo(localTasks.toExternalModels ())
154
+ assertThat(tasksRepository.getTasks()).isEqualTo(localTasks.toExternal ())
155
155
}
156
156
157
157
@Test(expected = Exception ::class )
@@ -171,8 +171,8 @@ class DefaultTasksRepositoryTest {
171
171
// Forcing an update will fetch tasks from remote
172
172
val newTasks = tasksRepository.getTasks(true )
173
173
174
- assertThat(newTasks).isEqualTo(networkTasks.toExternalModels ())
175
- assertThat(newTasks).isEqualTo(tasksLocalDataSource.tasks?.toExternalModels ())
174
+ assertThat(newTasks).isEqualTo(networkTasks.toExternal ())
175
+ assertThat(newTasks).isEqualTo(tasksLocalDataSource.tasks?.toExternal ())
176
176
assertThat(tasksLocalDataSource.tasks).isEqualTo(initialLocal)
177
177
}
178
178
@@ -210,11 +210,11 @@ class DefaultTasksRepositoryTest {
210
210
@Test
211
211
fun getTask_repositoryCachesAfterFirstApiCall () = runTest {
212
212
// Obtain a task from the local data source
213
- tasksLocalDataSource.tasks = mutableListOf (task1.toLocalModel ())
213
+ tasksLocalDataSource.tasks = mutableListOf (task1.toLocal ())
214
214
val initial = tasksRepository.getTask(task1.id)
215
215
216
216
// Change the tasks on the remote
217
- tasksNetworkDataSource.tasks = newTasks.toNetworkModels ().toMutableList()
217
+ tasksNetworkDataSource.tasks = newTasks.toNetwork ().toMutableList()
218
218
219
219
// Obtain the same task again
220
220
val second = tasksRepository.getTask(task1.id)
@@ -226,12 +226,12 @@ class DefaultTasksRepositoryTest {
226
226
@Test
227
227
fun getTask_forceRefresh () = runTest {
228
228
// Trigger the repository to load data, which loads from remote and caches
229
- tasksNetworkDataSource.tasks = mutableListOf (task1.toNetworkModel ())
229
+ tasksNetworkDataSource.tasks = mutableListOf (task1.toNetwork ())
230
230
val task1FirstTime = tasksRepository.getTask(task1.id, forceUpdate = true )
231
231
assertThat(task1FirstTime?.id).isEqualTo(task1.id)
232
232
233
233
// Configure the remote data source to return a different task
234
- tasksNetworkDataSource.tasks = mutableListOf (task2.toNetworkModel ())
234
+ tasksNetworkDataSource.tasks = mutableListOf (task2.toNetwork ())
235
235
236
236
// Force refresh
237
237
val task1SecondTime = tasksRepository.getTask(task1.id, true )
@@ -246,8 +246,8 @@ class DefaultTasksRepositoryTest {
246
246
fun clearCompletedTasks () = runTest {
247
247
val completedTask = task1.copy(isCompleted = true )
248
248
tasksLocalDataSource.tasks = mutableListOf (
249
- completedTask.toLocalModel (),
250
- task2.toLocalModel ()
249
+ completedTask.toLocal (),
250
+ task2.toLocal ()
251
251
)
252
252
tasksRepository.clearCompletedTasks()
253
253
0 commit comments