From cc09150141ad6910079b9d736cb1097651841f72 Mon Sep 17 00:00:00 2001 From: Alex Baker Date: Mon, 1 Feb 2021 15:20:19 -0600 Subject: [PATCH] Add opentask properties tests --- .../tasks/opentasks/OpenTasksDueDateTests.kt | 150 +++++++++++++ .../opentasks/OpenTasksPropertiesTests.kt | 199 +++++++++++++++++ .../opentasks/OpenTasksSynchronizerTest.kt | 202 +----------------- .../java/org/tasks/opentasks/OpenTasksTest.kt | 34 +++ .../org/tasks/opentasks/TestOpenTaskDao.kt | 6 +- .../java/org/tasks/makers/CaldavTaskMaker.kt | 2 + app/src/main/java/org/tasks/data/Tag.kt | 3 + 7 files changed, 392 insertions(+), 204 deletions(-) create mode 100644 app/src/androidTest/java/org/tasks/opentasks/OpenTasksDueDateTests.kt create mode 100644 app/src/androidTest/java/org/tasks/opentasks/OpenTasksPropertiesTests.kt create mode 100644 app/src/androidTest/java/org/tasks/opentasks/OpenTasksTest.kt diff --git a/app/src/androidTest/java/org/tasks/opentasks/OpenTasksDueDateTests.kt b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksDueDateTests.kt new file mode 100644 index 000000000..75e3a3615 --- /dev/null +++ b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksDueDateTests.kt @@ -0,0 +1,150 @@ +package org.tasks.opentasks + +import com.natpryce.makeiteasy.MakeItEasy.with +import dagger.hilt.android.testing.HiltAndroidTest +import dagger.hilt.android.testing.UninstallModules +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Test +import org.tasks.TestUtilities +import org.tasks.injection.ProductionModule +import org.tasks.makers.CaldavTaskMaker +import org.tasks.makers.CaldavTaskMaker.newCaldavTask +import org.tasks.makers.TaskMaker +import org.tasks.makers.TaskMaker.newTask +import org.tasks.time.DateTime +import java.util.* + +@UninstallModules(ProductionModule::class) +@HiltAndroidTest +class OpenTasksDueDateTests : OpenTasksTest() { + + @Test + fun readDueDatePositiveOffset() = runBlocking { + val (_, list) = withVtodo(ALL_DAY_DUE) + + TestUtilities.withTZ(BERLIN) { + synchronizer.sync() + } + + val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692") + val task = taskDao.fetch(caldavTask!!.task) + assertEquals( + DateTime(2021, 2, 1, 12, 0, 0, 0, BERLIN).millis, + task?.dueDate + ) + } + + @Test + fun writeDueDatePositiveOffset() = TestUtilities.withTZ(BERLIN) { + val (listId, list) = openTaskDao.insertList() + val taskId = taskDao.createNew(newTask( + with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1)) + )) + caldavDao.insert(newCaldavTask( + with(CaldavTaskMaker.CALENDAR, list.uuid), + with(CaldavTaskMaker.REMOTE_ID, "1234"), + with(CaldavTaskMaker.TASK, taskId) + )) + + synchronizer.sync() + + assertEquals( + 1612137600000, + openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time + ) + } + + @Test + fun readDueDateNoOffset() = runBlocking { + val (_, list) = withVtodo(ALL_DAY_DUE) + + TestUtilities.withTZ(LONDON) { + synchronizer.sync() + } + + val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692") + val task = taskDao.fetch(caldavTask!!.task) + assertEquals( + DateTime(2021, 2, 1, 12, 0, 0, 0, LONDON).millis, + task?.dueDate + ) + } + + @Test + fun writeDueDateNoOffset() = TestUtilities.withTZ(LONDON) { + val (listId, list) = openTaskDao.insertList() + val taskId = taskDao.createNew(newTask( + with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1)) + )) + caldavDao.insert(newCaldavTask( + with(CaldavTaskMaker.CALENDAR, list.uuid), + with(CaldavTaskMaker.REMOTE_ID, "1234"), + with(CaldavTaskMaker.TASK, taskId) + )) + + synchronizer.sync() + + assertEquals( + 1612137600000, + openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time + ) + } + + @Test + fun readDueDateNegativeOffset() = runBlocking { + val (_, list) = withVtodo(ALL_DAY_DUE) + + TestUtilities.withTZ(NEW_YORK) { + synchronizer.sync() + } + + val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692") + val task = taskDao.fetch(caldavTask!!.task) + assertEquals( + DateTime(2021, 2, 1, 12, 0, 0, 0, NEW_YORK).millis, + task?.dueDate + ) + } + + @Test + fun writeDueDateNegativeOffset() = TestUtilities.withTZ(NEW_YORK) { + val (listId, list) = openTaskDao.insertList() + val taskId = taskDao.createNew(newTask( + with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1)) + )) + caldavDao.insert(newCaldavTask( + with(CaldavTaskMaker.CALENDAR, list.uuid), + with(CaldavTaskMaker.REMOTE_ID, "1234"), + with(CaldavTaskMaker.TASK, taskId) + )) + + synchronizer.sync() + + assertEquals( + 1612137600000, + openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time + ) + } + + companion object { + private val BERLIN = TimeZone.getTimeZone("Europe/Berlin") + private val LONDON = TimeZone.getTimeZone("Europe/London") + private val NEW_YORK = TimeZone.getTimeZone("America/New_York") + + private val ALL_DAY_DUE = """ + BEGIN:VCALENDAR + VERSION:2.0 + PRODID:+//IDN tasks.org//android-110304//EN + BEGIN:VTODO + DTSTAMP:20210129T155402Z + UID:3863299529704302692 + CREATED:20210129T155318Z + LAST-MODIFIED:20210129T155329Z + SUMMARY:Due date + DUE;VALUE=DATE:20210201 + END:VTODO + END:VCALENDAR + """.trimIndent() + } +} \ No newline at end of file diff --git a/app/src/androidTest/java/org/tasks/opentasks/OpenTasksPropertiesTests.kt b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksPropertiesTests.kt new file mode 100644 index 000000000..bae7a5fc9 --- /dev/null +++ b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksPropertiesTests.kt @@ -0,0 +1,199 @@ +package org.tasks.opentasks + +import com.natpryce.makeiteasy.MakeItEasy.with +import com.todoroo.astrid.data.Task +import dagger.hilt.android.testing.HiltAndroidTest +import dagger.hilt.android.testing.UninstallModules +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Test +import org.tasks.caldav.iCalendar.Companion.getParent +import org.tasks.caldav.iCalendar.Companion.order +import org.tasks.data.TagDao +import org.tasks.data.TagDataDao +import org.tasks.injection.ProductionModule +import org.tasks.makers.CaldavTaskMaker +import org.tasks.makers.CaldavTaskMaker.CALENDAR +import org.tasks.makers.CaldavTaskMaker.REMOTE_ID +import org.tasks.makers.CaldavTaskMaker.REMOTE_ORDER +import org.tasks.makers.CaldavTaskMaker.newCaldavTask +import org.tasks.makers.TagDataMaker.NAME +import org.tasks.makers.TagDataMaker.newTagData +import org.tasks.makers.TagMaker.TAGDATA +import org.tasks.makers.TagMaker.TASK +import org.tasks.makers.TagMaker.newTag +import org.tasks.makers.TaskMaker +import org.tasks.makers.TaskMaker.newTask +import javax.inject.Inject + +@UninstallModules(ProductionModule::class) +@HiltAndroidTest +class OpenTasksPropertiesTests : OpenTasksTest() { + + @Inject lateinit var tagDataDao: TagDataDao + @Inject lateinit var tagDao: TagDao + + @Test + fun loadRemoteParentInfo() = runBlocking { + val (_, list) = withVtodo(SUBTASK) + + synchronizer.sync() + + val task = caldavDao.getTaskByRemoteId(list.uuid!!, "dfede1b0-435b-4bba-9708-2422e781747c") + assertEquals("7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7", task?.remoteParent) + } + + @Test + fun pushParentInfo() = runBlocking { + val (listId, list) = openTaskDao.insertList() + val taskId = taskDao.createNew(newTask(with(TaskMaker.PARENT, 594))) + + caldavDao.insert(newCaldavTask( + with(CALENDAR, list.uuid), + with(CaldavTaskMaker.TASK, taskId), + with(REMOTE_ID, "abcd"), + with(CaldavTaskMaker.REMOTE_PARENT, "1234") + )) + + synchronizer.sync() + + assertEquals("1234", openTaskDao.getTask(listId, "abcd")?.task?.getParent()) + } + + @Test + fun createNewTags() = runBlocking { + val (_, list) = withVtodo(TWO_TAGS) + + synchronizer.sync() + + assertEquals( + setOf("Tag1", "Tag2"), + caldavDao.getTaskByRemoteId(list.uuid!!, "3076145036806467726") + ?.task + ?.let { tagDao.getTagsForTask(it) } + ?.map { it.name } + ?.toSet() + ) + } + + @Test + fun matchExistingTag() = runBlocking { + val (_, list) = withVtodo(ONE_TAG) + val tag = newTagData(with(NAME, "Tag1")) + tagDataDao.createNew(tag) + + synchronizer.sync() + + assertEquals( + listOf(tag), + caldavDao.getTaskByRemoteId(list.uuid!!, "3076145036806467726") + ?.task + ?.let { tagDataDao.getTagDataForTask(it)} + ) + } + + @Test + fun uploadTags() = runBlocking { + val (listId, list) = openTaskDao.insertList() + val task = newTask().apply { taskDao.createNew(this) } + caldavDao.insert(newCaldavTask( + with(CALENDAR, list.uuid), + with(REMOTE_ID, "1234"), + with(CaldavTaskMaker.TASK, task.id) + )) + insertTag(task, "Tag1") + insertTag(task, "Tag2") + + synchronizer.sync() + + assertEquals( + setOf("Tag1", "Tag2"), + openTaskDao.getTask(listId, "1234")?.task?.categories?.toSet() + ) + } + + @Test + fun loadOrder() = runBlocking { + val (_, list) = withVtodo(ONE_TAG) + + synchronizer.sync() + + assertEquals( + 633734058L, + caldavDao.getTaskByRemoteId(list.uuid!!, "3076145036806467726")?.order + ) + } + + @Test + fun pushOrder() = runBlocking { + val (listId, list) = openTaskDao.insertList() + val task = newTask().apply { taskDao.createNew(this) } + caldavDao.insert(newCaldavTask( + with(CALENDAR, list.uuid), + with(REMOTE_ID, "1234"), + with(REMOTE_ORDER, 5678L), + with(CaldavTaskMaker.TASK, task.id) + )) + + synchronizer.sync() + + assertEquals( + 5678L, + openTaskDao.getTask(listId, "1234")?.task?.order + ) + } + + private suspend fun insertTag(task: Task, name: String) = + newTagData(with(NAME, name)) + .apply { tagDataDao.createNew(this) } + .let { tagDao.insert(newTag(with(TASK, task), with(TAGDATA, it))) } + + companion object { + private val SUBTASK = """ + BEGIN:VCALENDAR + VERSION:2.0 + PRODID:-//Nextcloud Tasks v0.13.6 + BEGIN:VTODO + UID:dfede1b0-435b-4bba-9708-2422e781747c + CREATED:20210128T150333 + LAST-MODIFIED:20210128T150338 + DTSTAMP:20210128T150338 + SUMMARY:Child + RELATED-TO:7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7 + END:VTODO + END:VCALENDAR + """.trimIndent() + + private val ONE_TAG = """ + BEGIN:VCALENDAR + VERSION:2.0 + PRODID:+//IDN tasks.org//android-110304//EN + BEGIN:VTODO + DTSTAMP:20210201T204211Z + UID:3076145036806467726 + CREATED:20210201T204143Z + LAST-MODIFIED:20210201T204209Z + SUMMARY:Tags + CATEGORIES:Tag1 + X-APPLE-SORT-ORDER:633734058 + END:VTODO + END:VCALENDAR + """.trimIndent() + + private val TWO_TAGS = """ + BEGIN:VCALENDAR + VERSION:2.0 + PRODID:+//IDN tasks.org//android-110304//EN + BEGIN:VTODO + DTSTAMP:20210201T204211Z + UID:3076145036806467726 + CREATED:20210201T204143Z + LAST-MODIFIED:20210201T204209Z + SUMMARY:Tags + CATEGORIES:Tag1,Tag2 + X-APPLE-SORT-ORDER:633734058 + END:VTODO + END:VCALENDAR + """.trimIndent() + } +} \ No newline at end of file diff --git a/app/src/androidTest/java/org/tasks/opentasks/OpenTasksSynchronizerTest.kt b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksSynchronizerTest.kt index 0040fcddb..aade198bb 100644 --- a/app/src/androidTest/java/org/tasks/opentasks/OpenTasksSynchronizerTest.kt +++ b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksSynchronizerTest.kt @@ -6,48 +6,22 @@ import dagger.hilt.android.testing.HiltAndroidTest import dagger.hilt.android.testing.UninstallModules import kotlinx.coroutines.runBlocking import org.junit.Assert.* -import org.junit.Before import org.junit.Test import org.tasks.R -import org.tasks.TestUtilities.withTZ -import org.tasks.caldav.iCalendar.Companion.getParent import org.tasks.data.CaldavAccount import org.tasks.data.CaldavAccount.Companion.TYPE_OPENTASKS import org.tasks.data.CaldavCalendar -import org.tasks.data.CaldavDao -import org.tasks.data.TaskDao -import org.tasks.injection.InjectingTestCase import org.tasks.injection.ProductionModule import org.tasks.makers.CaldavTaskMaker.CALENDAR import org.tasks.makers.CaldavTaskMaker.REMOTE_ID -import org.tasks.makers.CaldavTaskMaker.REMOTE_PARENT import org.tasks.makers.CaldavTaskMaker.TASK import org.tasks.makers.CaldavTaskMaker.newCaldavTask -import org.tasks.makers.TaskMaker -import org.tasks.makers.TaskMaker.PARENT import org.tasks.makers.TaskMaker.RRULE import org.tasks.makers.TaskMaker.newTask -import org.tasks.preferences.Preferences -import org.tasks.time.DateTime -import java.util.* -import javax.inject.Inject @UninstallModules(ProductionModule::class) @HiltAndroidTest -class OpenTasksSynchronizerTest : InjectingTestCase() { - @Inject lateinit var openTaskDao: TestOpenTaskDao - @Inject lateinit var caldavDao: CaldavDao - @Inject lateinit var synchronizer: OpenTasksSynchronizer - @Inject lateinit var preferences: Preferences - @Inject lateinit var taskDao: TaskDao - - @Before - override fun setUp() { - super.setUp() - - openTaskDao.reset() - preferences.setBoolean(R.string.p_debug_pro, true) - } +class OpenTasksSynchronizerTest : OpenTasksTest() { @Test fun createNewAccounts() = runBlocking { @@ -144,178 +118,4 @@ class OpenTasksSynchronizerTest : InjectingTestCase() { val task = openTaskDao.getTasks().first() assertEquals("FREQ=WEEKLY", task.rRule?.value) } - - @Test - fun loadRemoteParentInfo() = runBlocking { - val (listId, list) = openTaskDao.insertList() - openTaskDao.insertTask(listId, SUBTASK) - - synchronizer.sync() - - val task = caldavDao.getTaskByRemoteId(list.uuid!!, "dfede1b0-435b-4bba-9708-2422e781747c") - assertEquals("7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7", task?.remoteParent) - } - - @Test - fun pushParentInfo() = runBlocking { - val (listId, list) = openTaskDao.insertList() - val taskId = taskDao.createNew(newTask(with(PARENT, 594))) - - caldavDao.insert(newCaldavTask( - with(CALENDAR, list.uuid), - with(TASK, taskId), - with(REMOTE_ID, "abcd"), - with(REMOTE_PARENT, "1234") - )) - - synchronizer.sync() - - assertEquals("1234", openTaskDao.getTask(listId.toLong(), "abcd")?.task?.getParent()) - } - - @Test - fun readDueDatePositiveOffset() = runBlocking { - val (listId, list) = openTaskDao.insertList() - openTaskDao.insertTask(listId, ALL_DAY_DUE) - - withTZ(BERLIN) { - synchronizer.sync() - } - - val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692") - val task = taskDao.fetch(caldavTask!!.task) - assertEquals( - DateTime(2021, 2, 1, 12, 0, 0, 0, BERLIN).millis, - task?.dueDate - ) - } - - @Test - fun writeDueDatePositiveOffset() = withTZ(BERLIN) { - val (listId, list) = openTaskDao.insertList() - val taskId = taskDao.createNew(newTask( - with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1)) - )) - caldavDao.insert(newCaldavTask( - with(CALENDAR, list.uuid), - with(REMOTE_ID, "1234"), - with(TASK, taskId) - )) - - synchronizer.sync() - - assertEquals( - 1612137600000, - openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time - ) - } - - @Test - fun readDueDateNoOffset() = runBlocking { - val (listId, list) = openTaskDao.insertList() - openTaskDao.insertTask(listId, ALL_DAY_DUE) - - withTZ(LONDON) { - synchronizer.sync() - } - - val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692") - val task = taskDao.fetch(caldavTask!!.task) - assertEquals( - DateTime(2021, 2, 1, 12, 0, 0, 0, LONDON).millis, - task?.dueDate - ) - } - - @Test - fun writeDueDateNoOffset() = withTZ(LONDON) { - val (listId, list) = openTaskDao.insertList() - val taskId = taskDao.createNew(newTask( - with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1)) - )) - caldavDao.insert(newCaldavTask( - with(CALENDAR, list.uuid), - with(REMOTE_ID, "1234"), - with(TASK, taskId) - )) - - synchronizer.sync() - - assertEquals( - 1612137600000, - openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time - ) - } - - @Test - fun readDueDateNegativeOffset() = runBlocking { - val (listId, list) = openTaskDao.insertList() - openTaskDao.insertTask(listId, ALL_DAY_DUE) - - withTZ(NEW_YORK) { - synchronizer.sync() - } - - val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692") - val task = taskDao.fetch(caldavTask!!.task) - assertEquals( - DateTime(2021, 2, 1, 12, 0, 0, 0, NEW_YORK).millis, - task?.dueDate - ) - } - - @Test - fun writeDueDateNegativeOffset() = withTZ(NEW_YORK) { - val (listId, list) = openTaskDao.insertList() - val taskId = taskDao.createNew(newTask( - with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1)) - )) - caldavDao.insert(newCaldavTask( - with(CALENDAR, list.uuid), - with(REMOTE_ID, "1234"), - with(TASK, taskId) - )) - - synchronizer.sync() - - assertEquals( - 1612137600000, - openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time - ) - } - - companion object { - val BERLIN = TimeZone.getTimeZone("Europe/Berlin") - val LONDON = TimeZone.getTimeZone("Europe/London") - val NEW_YORK = TimeZone.getTimeZone("America/New_York") - val SUBTASK = """ - BEGIN:VCALENDAR - VERSION:2.0 - PRODID:-//Nextcloud Tasks v0.13.6 - BEGIN:VTODO - UID:dfede1b0-435b-4bba-9708-2422e781747c - CREATED:20210128T150333 - LAST-MODIFIED:20210128T150338 - DTSTAMP:20210128T150338 - SUMMARY:Child - RELATED-TO:7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7 - END:VTODO - END:VCALENDAR - """.trimIndent() - - val ALL_DAY_DUE = """ - BEGIN:VCALENDAR - VERSION:2.0 - PRODID:+//IDN tasks.org//android-110304//EN - BEGIN:VTODO - DTSTAMP:20210129T155402Z - UID:3863299529704302692 - CREATED:20210129T155318Z - LAST-MODIFIED:20210129T155329Z - SUMMARY:Due date - DUE;VALUE=DATE:20210201 - END:VTODO - END:VCALENDAR - """.trimIndent() - } } \ No newline at end of file diff --git a/app/src/androidTest/java/org/tasks/opentasks/OpenTasksTest.kt b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksTest.kt new file mode 100644 index 000000000..530386950 --- /dev/null +++ b/app/src/androidTest/java/org/tasks/opentasks/OpenTasksTest.kt @@ -0,0 +1,34 @@ +package org.tasks.opentasks + +import org.junit.Before +import org.tasks.R +import org.tasks.data.CaldavCalendar +import org.tasks.data.CaldavDao +import org.tasks.data.TaskDao +import org.tasks.injection.InjectingTestCase +import org.tasks.preferences.Preferences +import javax.inject.Inject + +abstract class OpenTasksTest : InjectingTestCase() { + @Inject lateinit var openTaskDao: TestOpenTaskDao + @Inject lateinit var preferences: Preferences + @Inject lateinit var caldavDao: CaldavDao + @Inject lateinit var synchronizer: OpenTasksSynchronizer + @Inject lateinit var taskDao: TaskDao + + @Before + override fun setUp() { + super.setUp() + + openTaskDao.reset() + preferences.setBoolean(R.string.p_debug_pro, true) + } + + protected suspend fun withVtodo(vtodo: String): Pair = + openTaskDao + .insertList() + .let { (listId, list) -> + openTaskDao.insertTask(listId, vtodo) + Pair(listId, list) + } +} \ No newline at end of file diff --git a/app/src/androidTest/java/org/tasks/opentasks/TestOpenTaskDao.kt b/app/src/androidTest/java/org/tasks/opentasks/TestOpenTaskDao.kt index 159a40d8c..bbda58b02 100644 --- a/app/src/androidTest/java/org/tasks/opentasks/TestOpenTaskDao.kt +++ b/app/src/androidTest/java/org/tasks/opentasks/TestOpenTaskDao.kt @@ -23,7 +23,7 @@ class TestOpenTaskDao @Inject constructor( type: String = DEFAULT_TYPE, account: String = DEFAULT_ACCOUNT, url: String = UUIDHelper.newUUID(), - ): Pair { + ): Pair { val uri = taskLists.buildUpon() .appendQueryParameter(TaskContract.CALLER_IS_SYNCADAPTER, "true") .appendQueryParameter(TaskContract.TaskLists.ACCOUNT_NAME, account) @@ -35,7 +35,7 @@ class TestOpenTaskDao @Inject constructor( .withValue(TaskContract.TaskListColumns.LIST_NAME, name) .withValue(TaskContract.TaskLists.SYNC_ENABLED, "1") ) - return Pair(result.uri!!.lastPathSegment!!, CaldavCalendar().apply { + return Pair(result.uri!!.lastPathSegment!!.toLong(), CaldavCalendar().apply { uuid = UUIDHelper.newUUID() this.name = name this.account = "$type:$account" @@ -44,7 +44,7 @@ class TestOpenTaskDao @Inject constructor( }) } - fun insertTask(listId: String, vtodo: String) { + fun insertTask(listId: Long, vtodo: String) { val ops = ArrayList() val task = MyAndroidTask(TestUtilities.fromString(vtodo)) ops.add(task.toBuilder(tasks).withValue(TaskContract.TaskColumns.LIST_ID, listId)) diff --git a/app/src/commonTest/java/org/tasks/makers/CaldavTaskMaker.kt b/app/src/commonTest/java/org/tasks/makers/CaldavTaskMaker.kt index 003f839ad..07b0f7b48 100644 --- a/app/src/commonTest/java/org/tasks/makers/CaldavTaskMaker.kt +++ b/app/src/commonTest/java/org/tasks/makers/CaldavTaskMaker.kt @@ -12,6 +12,7 @@ object CaldavTaskMaker { val TASK: Property = newProperty() val REMOTE_ID: Property = newProperty() val REMOTE_PARENT: Property = newProperty() + val REMOTE_ORDER: Property = newProperty() val VTODO: Property = newProperty() private val instantiator = Instantiator { @@ -19,6 +20,7 @@ object CaldavTaskMaker { task.remoteId = it.valueOf(REMOTE_ID, task.remoteId) task.remoteParent = it.valueOf(REMOTE_PARENT, null as String?) task.vtodo = it.valueOf(VTODO, null as String?) + task.order = it.valueOf(REMOTE_ORDER, null as Long?) task } diff --git a/app/src/main/java/org/tasks/data/Tag.kt b/app/src/main/java/org/tasks/data/Tag.kt index 542c8572e..03e71463f 100644 --- a/app/src/main/java/org/tasks/data/Tag.kt +++ b/app/src/main/java/org/tasks/data/Tag.kt @@ -47,6 +47,9 @@ class Tag { this.taskUid = taskUid } + override fun toString(): String = + "Tag(id=$id, task=$task, name=$name, tagUid=$tagUid, taskUid=$taskUid)" + companion object { const val KEY = "tags-tag" // $NON-NLS-1$ @JvmField val TABLE = Table("tags")