Inital

30 files changed, 5165 insertions, 0 deletions

diff --git a/app/storage/src/test/java/com/fsck/k9/preferences/StorageEditorTest.kt b/app/storage/src/test/java/com/fsck/k9/preferences/StorageEditorTest.kt
new file mode 100644
index 0000000..df3cc70
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/preferences/StorageEditorTest.kt
@@ -0,0 +1,207 @@
+package com.fsck.k9.preferences
+
+import assertk.assertThat
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperationCallback
+import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperations
+import com.fsck.k9.storage.K9RobolectricTest
+import org.junit.Test
+import org.mockito.ArgumentMatchers.any
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.doThrow
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.stubbing
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoMoreInteractions
+
+class StorageEditorTest : K9RobolectricTest() {
+    private val storage: Storage = Storage(mapOf("storage-key" to "storage-value"))
+    private val storageUpdater = TestStorageUpdater(storage)
+    private val storagePersister = mock<K9StoragePersister>()
+    private val storagePersisterOps = mock<StoragePersistOperations>()
+    private val editor = K9StorageEditor(storageUpdater, storagePersister)
+
+    private val workingMap = mutableMapOf<String, String>()
+
+    private val newValues: Map<String, String>
+        get() = storageUpdater.newStorage!!.all
+
+    @Test
+    fun commit_exception() {
+        stubbing(storagePersister) {
+            on { doInTransaction(any()) } doThrow RuntimeException()
+        }
+
+        val success = editor.commit()
+
+        assertThat(success).isFalse()
+    }
+
+    @Test
+    fun commit_trivial() {
+        prepareStoragePersisterMock()
+
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(storage.all)
+
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun putBoolean() {
+        prepareStoragePersisterMock()
+
+        editor.putBoolean("x", true)
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "storage-value", "x" to "true"))
+        verify(storagePersisterOps).put("x", "true")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun putInt() {
+        prepareStoragePersisterMock()
+
+        editor.putInt("x", 123)
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "storage-value", "x" to "123"))
+        verify(storagePersisterOps).put("x", "123")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun putLong() {
+        prepareStoragePersisterMock()
+
+        editor.putLong("x", 1234)
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "storage-value", "x" to "1234"))
+        verify(storagePersisterOps).put("x", "1234")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun putString() {
+        prepareStoragePersisterMock()
+
+        editor.putString("x", "y")
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "storage-value", "x" to "y"))
+        verify(storagePersisterOps).put("x", "y")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun putString_duplicateSame() {
+        prepareStoragePersisterMock()
+
+        editor.putString("storage-key", "storage-value")
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "storage-value"))
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun putString_duplicateOther() {
+        prepareStoragePersisterMock()
+
+        editor.putString("storage-key", "other-value")
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "other-value"))
+        verify(storagePersisterOps).put("storage-key", "other-value")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun putString_removedDuplicate() {
+        prepareStoragePersisterMock()
+
+        editor.remove("storage-key")
+        editor.putString("storage-key", "storage-value")
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "storage-value"))
+        verify(storagePersisterOps).remove("storage-key")
+        verify(storagePersisterOps).put("storage-key", "storage-value")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun `remove key that doesn't exist`() {
+        prepareStoragePersisterMock()
+
+        editor.remove("x")
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEqualTo(mapOf("storage-key" to "storage-value"))
+        verify(storagePersisterOps).remove("x")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    @Test
+    fun remove() {
+        prepareStoragePersisterMock()
+
+        editor.remove("storage-key")
+        val success = editor.commit()
+
+        assertThat(success).isTrue()
+        assertThat(newValues).isEmpty()
+        verify(storagePersisterOps).remove("storage-key")
+        verifyNoMoreInteractions(storagePersisterOps)
+    }
+
+    private fun prepareStoragePersisterMock() {
+        stubbing(storagePersisterOps) {
+            on { put(any(), any()) } doAnswer {
+                val key = it.getArgument<String>(0)
+                val value = it.getArgument<String>(1)
+                workingMap[key] = value
+            }
+
+            on { remove(any()) } doAnswer {
+                val key = it.getArgument<String>(0)
+                workingMap.remove(key)
+
+                Unit
+            }
+        }
+
+        stubbing(storagePersister) {
+            on { doInTransaction(any()) } doAnswer {
+                val operationCallback = it.getArgument<StoragePersistOperationCallback>(0)
+
+                operationCallback.beforePersistTransaction(workingMap)
+                operationCallback.persist(storagePersisterOps)
+                operationCallback.onPersistTransactionSuccess(workingMap)
+            }
+        }
+    }
+}
+
+class TestStorageUpdater(private val currentStorage: Storage) : StorageUpdater {
+    var newStorage: Storage? = null
+
+    override fun updateStorage(updater: (currentStorage: Storage) -> Storage) {
+        newStorage = updater(currentStorage)
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
new file mode 100644
index 0000000..95898e1
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
@@ -0,0 +1,120 @@
+package com.fsck.k9.preferences
+
+import android.content.Context
+import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperationCallback
+import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperations
+import com.fsck.k9.storage.K9RobolectricTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.inOrder
+import org.mockito.kotlin.never
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoMoreInteractions
+import org.robolectric.RuntimeEnvironment
+
+class StoragePersisterTest : K9RobolectricTest() {
+    private var context: Context = RuntimeEnvironment.getApplication()
+    private var storagePersister = K9StoragePersister(context)
+
+    @Test
+    fun doInTransaction_order() {
+        val operationCallback = prepareCallback()
+        storagePersister.doInTransaction(operationCallback)
+
+        inOrder(operationCallback) {
+            verify(operationCallback).beforePersistTransaction(any())
+            verify(operationCallback).persist(any())
+            verify(operationCallback).onPersistTransactionSuccess(any())
+        }
+        verifyNoMoreInteractions(operationCallback)
+    }
+
+    @Test
+    fun doInTransaction_put() {
+        val operationCallback = prepareCallback(
+            persistOp = { ops -> ops.put("x", "y") },
+            onSuccess = { map ->
+                assertEquals(1, map.size)
+                assertEquals("y", map["x"])
+            }
+        )
+
+        storagePersister.doInTransaction(operationCallback)
+
+        val values = storagePersister.loadValues().all
+        assertEquals(1, values.size)
+        assertEquals("y", values["x"])
+    }
+
+    @Test
+    fun doInTransaction_putAndThrow() {
+        val exception = Exception("boom")
+        val operationCallback = prepareCallback(
+            persistOp = { ops ->
+                ops.put("x", "y")
+                throw exception
+            }
+        )
+
+        try {
+            storagePersister.doInTransaction(operationCallback)
+            fail("expected exception")
+        } catch (e: Exception) {
+            assertSame(exception, e)
+        }
+
+        val values = storagePersister.loadValues()
+        assertTrue(values.isEmpty())
+        verify(operationCallback, never()).onPersistTransactionSuccess(any())
+    }
+
+    @Test
+    fun doInTransaction_remove() {
+        val operationCallback = prepareCallback(
+            before = { map -> map["x"] = "y" },
+            persistOp = { ops -> ops.remove("x") },
+            onSuccess = { map -> assertTrue(map.isEmpty()) }
+        )
+
+        storagePersister.doInTransaction(operationCallback)
+
+        val values = storagePersister.loadValues()
+        assertTrue(values.isEmpty())
+    }
+
+    @Test
+    fun doInTransaction_before_preserveButNotPersist() {
+        val operationCallback = prepareCallback(
+            before = { map -> map["x"] = "y" },
+            onSuccess = { map -> assertEquals("y", map["x"]) }
+        )
+
+        storagePersister.doInTransaction(operationCallback)
+
+        val values = storagePersister.loadValues()
+        assertTrue(values.isEmpty())
+    }
+
+    private fun prepareCallback(
+        persistOp: ((StoragePersistOperations) -> Unit)? = null,
+        before: ((MutableMap<String, String>) -> Unit)? = null,
+        onSuccess: ((Map<String, String>) -> Unit)? = null
+    ): StoragePersistOperationCallback = spy(object : StoragePersistOperationCallback {
+        override fun beforePersistTransaction(workingStorage: MutableMap<String, String>) {
+            before?.invoke(workingStorage)
+        }
+
+        override fun persist(ops: StoragePersistOperations) {
+            persistOp?.invoke(ops)
+        }
+
+        override fun onPersistTransactionSuccess(workingStorage: Map<String, String>) {
+            onSuccess?.invoke(workingStorage)
+        }
+    })
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/K9RobolectricTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/K9RobolectricTest.kt
new file mode 100644
index 0000000..eeb24ec
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/K9RobolectricTest.kt
@@ -0,0 +1,16 @@
+package com.fsck.k9.storage
+
+import android.app.Application
+import org.junit.runner.RunWith
+import org.koin.test.AutoCloseKoinTest
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * A Robolectric test that creates an instance of our [Application] test class [TestApp].
+ *
+ * See also [RobolectricTest].
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(application = TestApp::class)
+abstract class K9RobolectricTest : AutoCloseKoinTest()
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/RobolectricTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/RobolectricTest.kt
new file mode 100644
index 0000000..0e40c60
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/RobolectricTest.kt
@@ -0,0 +1,15 @@
+package com.fsck.k9.storage
+
+import android.app.Application
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * A Robolectric test that does not create an instance of our [Application] class.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(application = EmptyApplication::class)
+abstract class RobolectricTest
+
+class EmptyApplication : Application()
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/StoreSchemaDefinitionTest.java b/app/storage/src/test/java/com/fsck/k9/storage/StoreSchemaDefinitionTest.java
new file mode 100644
index 0000000..325eac1
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/StoreSchemaDefinitionTest.java
@@ -0,0 +1,424 @@
+package com.fsck.k9.storage;
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import android.app.Application;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.text.TextUtils;
+
+import com.fsck.k9.Account;
+import com.fsck.k9.core.BuildConfig;
+import com.fsck.k9.mail.AuthType;
+import com.fsck.k9.mail.ConnectionSecurity;
+import com.fsck.k9.mail.MessagingException;
+import com.fsck.k9.mail.ServerSettings;
+import com.fsck.k9.mailstore.LocalStore;
+import com.fsck.k9.mailstore.LockableDatabase;
+import com.fsck.k9.mailstore.MigrationsHelper;
+import com.fsck.k9.mailstore.StorageManager;
+import org.junit.Before;
+import org.junit.Test;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.shadows.ShadowLog;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+
+public class StoreSchemaDefinitionTest extends K9RobolectricTest {
+    private StoreSchemaDefinition storeSchemaDefinition;
+
+
+    @Before
+    public void setUp() throws MessagingException {
+        ShadowLog.stream = System.out;
+
+        Application application = RuntimeEnvironment.getApplication();
+        StorageManager.getInstance(application);
+
+        storeSchemaDefinition = createStoreSchemaDefinition();
+    }
+
+    @Test
+    public void getVersion_shouldReturnCurrentDatabaseVersion() {
+        int version = storeSchemaDefinition.getVersion();
+
+        assertEquals(StoreSchemaDefinition.DB_VERSION, version);
+    }
+
+    @Test
+    public void doDbUpgrade_withEmptyDatabase_shouldSetsDatabaseVersion() {
+        SQLiteDatabase database = SQLiteDatabase.create(null);
+
+        storeSchemaDefinition.doDbUpgrade(database);
+
+        assertEquals(StoreSchemaDefinition.DB_VERSION, database.getVersion());
+    }
+
+    @Test
+    public void doDbUpgrade_withBadDatabase_shouldThrowInDebugBuild() {
+        if (BuildConfig.DEBUG) {
+            SQLiteDatabase database = SQLiteDatabase.create(null);
+            database.setVersion(61);
+
+            try {
+                storeSchemaDefinition.doDbUpgrade(database);
+                fail("Expected Error");
+            } catch (Error e) {
+                assertEquals("Exception while upgrading database", e.getMessage());
+            }
+        }
+    }
+
+    @Test
+    public void doDbUpgrade_withV61_shouldUpgradeDatabaseToLatestVersion() {
+        SQLiteDatabase database = createV61Database();
+
+        storeSchemaDefinition.doDbUpgrade(database);
+
+        assertEquals(StoreSchemaDefinition.DB_VERSION, database.getVersion());
+    }
+
+    @Test
+    public void doDbUpgrade_withV61() {
+        SQLiteDatabase database = createV61Database();
+        insertMessageWithSubject(database, "Test Email");
+
+        storeSchemaDefinition.doDbUpgrade(database);
+
+        assertMessageWithSubjectExists(database, "Test Email");
+    }
+
+    @Test
+    public void doDbUpgrade_fromV61_shouldResultInSameTables() {
+        SQLiteDatabase newDatabase = createNewDatabase();
+        SQLiteDatabase upgradedDatabase = createV61Database();
+
+        storeSchemaDefinition.doDbUpgrade(upgradedDatabase);
+
+        assertDatabaseTablesEquals(newDatabase, upgradedDatabase);
+    }
+
+    @Test
+    public void doDbUpgrade_fromV61_shouldResultInSameTriggers() {
+        SQLiteDatabase newDatabase = createNewDatabase();
+        SQLiteDatabase upgradedDatabase = createV61Database();
+
+        storeSchemaDefinition.doDbUpgrade(upgradedDatabase);
+
+        assertDatabaseTriggersEquals(newDatabase, upgradedDatabase);
+    }
+
+    @Test
+    public void doDbUpgrade_fromV61_shouldResultInSameIndexes() {
+        SQLiteDatabase newDatabase = createNewDatabase();
+        SQLiteDatabase upgradedDatabase = createV61Database();
+
+        storeSchemaDefinition.doDbUpgrade(upgradedDatabase);
+
+        assertDatabaseIndexesEquals(newDatabase, upgradedDatabase);
+    }
+
+
+    private SQLiteDatabase createV61Database() {
+        SQLiteDatabase database = SQLiteDatabase.create(null);
+        initV61Database(database);
+        return database;
+    }
+
+    private void initV61Database(SQLiteDatabase db) {
+
+        db.beginTransaction();
+
+        db.execSQL("DROP TABLE IF EXISTS folders");
+        db.execSQL("CREATE TABLE folders (" +
+                "id INTEGER PRIMARY KEY," +
+                "name TEXT, " +
+                "last_updated INTEGER, " +
+                "unread_count INTEGER, " +
+                "visible_limit INTEGER, " +
+                "status TEXT, " +
+                "push_state TEXT, " +
+                "last_pushed INTEGER, " +
+                "flagged_count INTEGER default 0, " +
+                "integrate INTEGER, " +
+                "top_group INTEGER, " +
+                "poll_class TEXT, " +
+                "push_class TEXT, " +
+                "display_class TEXT, " +
+                "notify_class TEXT default 'INHERITED', " +
+                "more_messages TEXT default \"unknown\"" +
+                ")");
+
+        db.execSQL("CREATE INDEX IF NOT EXISTS folder_name ON folders (name)");
+        db.execSQL("DROP TABLE IF EXISTS messages");
+        db.execSQL("CREATE TABLE messages (" +
+                "id INTEGER PRIMARY KEY, " +
+                "deleted INTEGER default 0, " +
+                "folder_id INTEGER, " +
+                "uid TEXT, " +
+                "subject TEXT, " +
+                "date INTEGER, " +
+                "flags TEXT, " +
+                "sender_list TEXT, " +
+                "to_list TEXT, " +
+                "cc_list TEXT, " +
+                "bcc_list TEXT, " +
+                "reply_to_list TEXT, " +
+                "attachment_count INTEGER, " +
+                "internal_date INTEGER, " +
+                "message_id TEXT, " +
+                "preview_type TEXT default \"none\", " +
+                "preview TEXT, " +
+                "mime_type TEXT, "+
+                "normalized_subject_hash INTEGER, " +
+                "empty INTEGER default 0, " +
+                "read INTEGER default 0, " +
+                "flagged INTEGER default 0, " +
+                "answered INTEGER default 0, " +
+                "forwarded INTEGER default 0, " +
+                "message_part_id INTEGER" +
+                ")");
+
+        db.execSQL("DROP TABLE IF EXISTS message_parts");
+        db.execSQL("CREATE TABLE message_parts (" +
+                "id INTEGER PRIMARY KEY, " +
+                "type INTEGER NOT NULL, " +
+                "root INTEGER, " +
+                "parent INTEGER NOT NULL, " +
+                "seq INTEGER NOT NULL, " +
+                "mime_type TEXT, " +
+                "decoded_body_size INTEGER, " +
+                "display_name TEXT, " +
+                "header TEXT, " +
+                "encoding TEXT, " +
+                "charset TEXT, " +
+                "data_location INTEGER NOT NULL, " +
+                "data BLOB, " +
+                "preamble TEXT, " +
+                "epilogue TEXT, " +
+                "boundary TEXT, " +
+                "content_id TEXT, " +
+                "server_extra TEXT" +
+                ")");
+
+        db.execSQL("CREATE TRIGGER set_message_part_root " +
+                "AFTER INSERT ON message_parts " +
+                "BEGIN " +
+                "UPDATE message_parts SET root=id WHERE root IS NULL AND ROWID = NEW.ROWID; " +
+                "END");
+
+        db.execSQL("CREATE INDEX IF NOT EXISTS msg_uid ON messages (uid, folder_id)");
+        db.execSQL("DROP INDEX IF EXISTS msg_folder_id");
+        db.execSQL("DROP INDEX IF EXISTS msg_folder_id_date");
+        db.execSQL("CREATE INDEX IF NOT EXISTS msg_folder_id_deleted_date ON messages (folder_id,deleted,internal_date)");
+
+        db.execSQL("DROP INDEX IF EXISTS msg_empty");
+        db.execSQL("CREATE INDEX IF NOT EXISTS msg_empty ON messages (empty)");
+
+        db.execSQL("DROP INDEX IF EXISTS msg_read");
+        db.execSQL("CREATE INDEX IF NOT EXISTS msg_read ON messages (read)");
+
+        db.execSQL("DROP INDEX IF EXISTS msg_flagged");
+        db.execSQL("CREATE INDEX IF NOT EXISTS msg_flagged ON messages (flagged)");
+
+        db.execSQL("DROP INDEX IF EXISTS msg_composite");
+        db.execSQL("CREATE INDEX IF NOT EXISTS msg_composite ON messages (deleted, empty,folder_id,flagged,read)");
+
+
+        db.execSQL("DROP TABLE IF EXISTS threads");
+        db.execSQL("CREATE TABLE threads (" +
+                "id INTEGER PRIMARY KEY, " +
+                "message_id INTEGER, " +
+                "root INTEGER, " +
+                "parent INTEGER" +
+                ")");
+
+        db.execSQL("DROP INDEX IF EXISTS threads_message_id");
+        db.execSQL("CREATE INDEX IF NOT EXISTS threads_message_id ON threads (message_id)");
+
+        db.execSQL("DROP INDEX IF EXISTS threads_root");
+        db.execSQL("CREATE INDEX IF NOT EXISTS threads_root ON threads (root)");
+
+        db.execSQL("DROP INDEX IF EXISTS threads_parent");
+        db.execSQL("CREATE INDEX IF NOT EXISTS threads_parent ON threads (parent)");
+
+        db.execSQL("DROP TRIGGER IF EXISTS set_thread_root");
+        db.execSQL("CREATE TRIGGER set_thread_root " +
+                "AFTER INSERT ON threads " +
+                "BEGIN " +
+                "UPDATE threads SET root=id WHERE root IS NULL AND ROWID = NEW.ROWID; " +
+                "END");
+
+        db.execSQL("DROP TABLE IF EXISTS pending_commands");
+        db.execSQL("CREATE TABLE pending_commands " +
+                "(id INTEGER PRIMARY KEY, command TEXT, data TEXT)");
+
+        db.execSQL("DROP TRIGGER IF EXISTS delete_folder");
+        db.execSQL("CREATE TRIGGER delete_folder BEFORE DELETE ON folders BEGIN DELETE FROM messages WHERE old.id = folder_id; END;");
+
+        db.execSQL("DROP TRIGGER IF EXISTS delete_message");
+        db.execSQL("CREATE TRIGGER delete_message " +
+                "BEFORE DELETE ON messages " +
+                "BEGIN " +
+                "DELETE FROM message_parts WHERE root = OLD.message_part_id; " +
+                "DELETE FROM messages_fulltext WHERE docid = OLD.id; " +
+                "END");
+
+        db.execSQL("DROP TABLE IF EXISTS messages_fulltext");
+        db.execSQL("CREATE VIRTUAL TABLE messages_fulltext USING fts4 (fulltext)");
+
+        db.setVersion(61);
+
+        db.setTransactionSuccessful();
+        db.endTransaction();
+    }
+
+    private void assertMessageWithSubjectExists(SQLiteDatabase database, String subject) {
+        Cursor cursor = database.query("messages", new String[] { "subject" }, null, null, null, null, null);
+        try {
+            assertTrue(cursor.moveToFirst());
+            assertEquals(subject, cursor.getString(0));
+        } finally {
+            cursor.close();
+        }
+    }
+
+    private void assertDatabaseTablesEquals(SQLiteDatabase expected, SQLiteDatabase actual) {
+        List<String> tablesInNewDatabase = tablesInDatabase(expected);
+        Collections.sort(tablesInNewDatabase);
+
+        List<String> tablesInUpgradedDatabase = tablesInDatabase(actual);
+        Collections.sort(tablesInUpgradedDatabase);
+
+        assertEquals(tablesInNewDatabase, tablesInUpgradedDatabase);
+    }
+
+    private void assertDatabaseTriggersEquals(SQLiteDatabase expected, SQLiteDatabase actual) {
+        List<String> triggersInNewDatabase = triggersInDatabase(expected);
+        Collections.sort(triggersInNewDatabase);
+
+        List<String> triggersInUpgradedDatabase = triggersInDatabase(actual);
+        Collections.sort(triggersInUpgradedDatabase);
+
+        assertEquals(triggersInNewDatabase, triggersInUpgradedDatabase);
+    }
+
+    private void assertDatabaseIndexesEquals(SQLiteDatabase expected, SQLiteDatabase actual) {
+        List<String> indexesInNewDatabase = indexesInDatabase(expected);
+        Collections.sort(indexesInNewDatabase);
+
+        List<String> indexesInUpgradedDatabase = indexesInDatabase(actual);
+        Collections.sort(indexesInUpgradedDatabase);
+
+        assertEquals(indexesInNewDatabase, indexesInUpgradedDatabase);
+    }
+
+    private List<String> tablesInDatabase(SQLiteDatabase db) {
+        return objectsInDatabase(db, "table");
+    }
+
+    private List<String> triggersInDatabase(SQLiteDatabase db) {
+        return objectsInDatabase(db, "trigger");
+    }
+
+    private List<String> indexesInDatabase(SQLiteDatabase db) {
+        return objectsInDatabase(db, "index");
+    }
+
+    private List<String> objectsInDatabase(SQLiteDatabase db, String type) {
+        List<String> databaseObjects = new ArrayList<>();
+        Cursor cursor = db.rawQuery("SELECT sql FROM sqlite_master WHERE type = ? AND sql IS NOT NULL",
+                new String[] { type });
+        try {
+            while (cursor.moveToNext()) {
+                String sql = cursor.getString(cursor.getColumnIndex("sql"));
+                String resortedSql = "table".equals(type) ? sortTableColumns(sql) : sql;
+                databaseObjects.add(resortedSql);
+            }
+        } finally {
+            cursor.close();
+        }
+
+        return databaseObjects;
+    }
+
+    private String sortTableColumns(String sql) {
+        int positionOfColumnDefinitions = sql.indexOf('(');
+        String columnDefinitionsSql = sql.substring(positionOfColumnDefinitions + 1, sql.length() - 1);
+        String[] columnDefinitions = columnDefinitionsSql.split(" *, *(?![^(]*\\))");
+        Arrays.sort(columnDefinitions);
+
+        String sqlPrefix = sql.substring(0, positionOfColumnDefinitions + 1);
+        String sortedColumnDefinitionsSql = TextUtils.join(", ", columnDefinitions);
+        return sqlPrefix + sortedColumnDefinitionsSql + ")";
+    }
+
+    private void insertMessageWithSubject(SQLiteDatabase database, String subject) {
+        ContentValues data = new ContentValues();
+        data.put("subject", subject);
+        long rowId = database.insert("messages", null, data);
+        assertNotEquals(-1, rowId);
+    }
+
+    private StoreSchemaDefinition createStoreSchemaDefinition() throws MessagingException {
+        final Account account = createAccount();
+        final LockableDatabase lockableDatabase = createLockableDatabase();
+        final LocalStore localStore = mock(LocalStore.class);
+        when(localStore.getDatabase()).thenReturn(lockableDatabase);
+
+        MigrationsHelper migrationsHelper = new MigrationsHelper() {
+            @Override
+            public Account getAccount() {
+                return account;
+            }
+
+            @Override
+            public void saveAccount() {
+                // Do nothing
+            }
+        };
+
+        return new StoreSchemaDefinition(migrationsHelper);
+    }
+
+    private LockableDatabase createLockableDatabase() throws MessagingException {
+        LockableDatabase lockableDatabase = mock(LockableDatabase.class);
+        when(lockableDatabase.execute(anyBoolean(), any(LockableDatabase.DbCallback.class))).thenReturn(false);
+        return lockableDatabase;
+    }
+
+    private Account createAccount() {
+        Account account = mock(Account.class);
+        when(account.getLegacyInboxFolder()).thenReturn("Inbox");
+        when(account.getImportedTrashFolder()).thenReturn("Trash");
+        when(account.getImportedDraftsFolder()).thenReturn("Drafts");
+        when(account.getImportedSpamFolder()).thenReturn("Spam");
+        when(account.getImportedSentFolder()).thenReturn("Sent");
+        when(account.getImportedArchiveFolder()).thenReturn(null);
+        when(account.getLocalStorageProviderId()).thenReturn(StorageManager.InternalStorageProvider.ID);
+
+        ServerSettings incomingServerSettings = new ServerSettings("dummy", "", -1, ConnectionSecurity.NONE,
+                AuthType.AUTOMATIC, "", "", null);
+        when(account.getIncomingServerSettings()).thenReturn(incomingServerSettings);
+        return account;
+    }
+
+    private SQLiteDatabase createNewDatabase() {
+        SQLiteDatabase database = SQLiteDatabase.create(null);
+        storeSchemaDefinition.doDbUpgrade(database);
+        return database;
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/TestApp.kt b/app/storage/src/test/java/com/fsck/k9/storage/TestApp.kt
new file mode 100644
index 0000000..97dbdb0
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/TestApp.kt
@@ -0,0 +1,35 @@
+package com.fsck.k9.storage
+
+import android.app.Application
+import com.fsck.k9.AppConfig
+import com.fsck.k9.Core
+import com.fsck.k9.CoreResourceProvider
+import com.fsck.k9.DI
+import com.fsck.k9.K9
+import com.fsck.k9.backend.BackendManager
+import com.fsck.k9.coreModules
+import com.fsck.k9.crypto.EncryptionExtractor
+import com.fsck.k9.preferences.K9StoragePersister
+import com.fsck.k9.preferences.StoragePersister
+import org.koin.dsl.module
+import org.mockito.kotlin.mock
+
+class TestApp : Application() {
+    override fun onCreate() {
+        Core.earlyInit()
+
+        super.onCreate()
+        DI.start(this, coreModules + storageModule + testModule)
+
+        K9.init(this)
+        Core.init(this)
+    }
+}
+
+val testModule = module {
+    single { AppConfig(emptyList()) }
+    single { mock<CoreResourceProvider>() }
+    single { mock<EncryptionExtractor>() }
+    single<StoragePersister> { K9StoragePersister(get()) }
+    single { mock<BackendManager>() }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/CheckFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/CheckFolderOperationsTest.kt
new file mode 100644
index 0000000..1c25c54
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/CheckFolderOperationsTest.kt
@@ -0,0 +1,65 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class CheckFolderOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val checkFolderOperations = CheckFolderOperations(lockableDatabase)
+
+    @Test
+    fun `single folder not included in Unified Inbox`() {
+        val folderIds = listOf(sqliteDatabase.createFolder(integrate = false))
+
+        val result = checkFolderOperations.areAllIncludedInUnifiedInbox(folderIds)
+
+        assertThat(result).isFalse()
+    }
+
+    @Test
+    fun `single folder included in Unified Inbox`() {
+        val folderIds = listOf(sqliteDatabase.createFolder(integrate = true))
+
+        val result = checkFolderOperations.areAllIncludedInUnifiedInbox(folderIds)
+
+        assertThat(result).isTrue()
+    }
+
+    @Test
+    fun `not all folders included in Unified Inbox`() {
+        val folderIds = listOf(
+            sqliteDatabase.createFolder(integrate = true),
+            sqliteDatabase.createFolder(integrate = false)
+        )
+
+        val result = checkFolderOperations.areAllIncludedInUnifiedInbox(folderIds)
+
+        assertThat(result).isFalse()
+    }
+
+    @Test
+    fun `1000 folders included in Unified Inbox`() {
+        val folderIds = List(1000) {
+            sqliteDatabase.createFolder(integrate = true)
+        }
+
+        val result = checkFolderOperations.areAllIncludedInUnifiedInbox(folderIds)
+
+        assertThat(result).isTrue()
+    }
+
+    @Test
+    fun `999 of 1000 folders included in Unified Inbox`() {
+        val folderIds = List(999) {
+            sqliteDatabase.createFolder(integrate = true)
+        } + sqliteDatabase.createFolder(integrate = false)
+
+        val result = checkFolderOperations.areAllIncludedInUnifiedInbox(folderIds)
+
+        assertThat(result).isFalse()
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
new file mode 100644
index 0000000..77dc7b0
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
@@ -0,0 +1,114 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import org.junit.Assert.fail
+import org.junit.Test
+
+class ChunkedDatabaseOperationsTest {
+    @Test(expected = IllegalArgumentException::class)
+    fun `empty list`() {
+        performChunkedOperation(
+            arguments = emptyList(),
+            argumentTransformation = Int::toString,
+            operation = ::failCallback
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `chunkSize = 0`() {
+        performChunkedOperation(
+            arguments = listOf(1),
+            argumentTransformation = Int::toString,
+            chunkSize = 0,
+            operation = ::failCallback
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `chunkSize = 1001`() {
+        performChunkedOperation(
+            arguments = listOf(1),
+            argumentTransformation = Int::toString,
+            chunkSize = 1001,
+            operation = ::failCallback
+        )
+    }
+
+    @Test
+    fun `single item`() {
+        val chunks = mutableListOf<Pair<String, Array<String>>>()
+
+        performChunkedOperation(
+            arguments = listOf(1),
+            argumentTransformation = Int::toString
+        ) { selectionSet, selectionArguments ->
+            chunks.add(selectionSet to selectionArguments)
+            Unit
+        }
+
+        assertThat(chunks).hasSize(1)
+        with(chunks.first()) {
+            assertThat(first).isEqualTo("IN (?)")
+            assertThat(second).isEqualTo(arrayOf("1"))
+        }
+    }
+
+    @Test
+    fun `2 items with chunk size of 1`() {
+        val chunks = mutableListOf<Pair<String, Array<String>>>()
+
+        performChunkedOperation(
+            arguments = listOf(1, 2),
+            argumentTransformation = Int::toString,
+            chunkSize = 1
+        ) { selectionSet, selectionArguments ->
+            chunks.add(selectionSet to selectionArguments)
+            Unit
+        }
+
+        assertThat(chunks).hasSize(2)
+        with(chunks[0]) {
+            assertThat(first).isEqualTo("IN (?)")
+            assertThat(second).isEqualTo(arrayOf("1"))
+        }
+        with(chunks[1]) {
+            assertThat(first).isEqualTo("IN (?)")
+            assertThat(second).isEqualTo(arrayOf("2"))
+        }
+    }
+
+    @Test
+    fun `14 items with chunk size of 5`() {
+        val chunks = mutableListOf<Pair<String, Array<String>>>()
+
+        performChunkedOperation(
+            arguments = (1..14).toList(),
+            argumentTransformation = Int::toString,
+            chunkSize = 5
+        ) { selectionSet, selectionArguments ->
+            chunks.add(selectionSet to selectionArguments)
+            Unit
+        }
+
+        assertThat(chunks).hasSize(3)
+        with(chunks[0]) {
+            assertThat(first).isEqualTo("IN (?,?,?,?,?)")
+            assertThat(second).isEqualTo(arrayOf("1", "2", "3", "4", "5"))
+        }
+        with(chunks[1]) {
+            assertThat(first).isEqualTo("IN (?,?,?,?,?)")
+            assertThat(second).isEqualTo(arrayOf("6", "7", "8", "9", "10"))
+        }
+        with(chunks[2]) {
+            assertThat(first).isEqualTo("IN (?,?,?,?)")
+            assertThat(second).isEqualTo(arrayOf("11", "12", "13", "14"))
+        }
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    private fun failCallback(selectionSet: String, selectionArguments: Array<String>) {
+        fail("'operation' callback called when it shouldn't")
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/CopyMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/CopyMessageOperationsTest.kt
new file mode 100644
index 0000000..84ac34e
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/CopyMessageOperationsTest.kt
@@ -0,0 +1,252 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotIn
+import assertk.assertions.isNull
+import com.fsck.k9.mail.crlf
+import com.fsck.k9.mailstore.StorageManager
+import com.fsck.k9.storage.RobolectricTest
+import okio.buffer
+import okio.sink
+import okio.source
+import org.junit.After
+import org.junit.Test
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+
+private const val ACCOUNT_UUID = "00000000-0000-4000-0000-000000000000"
+
+class CopyMessageOperationsTest : RobolectricTest() {
+    private val messagePartDirectory = createRandomTempDirectory()
+    private val sqliteDatabase = createDatabase()
+    private val storageManager = mock<StorageManager> {
+        on { getAttachmentDirectory(eq(ACCOUNT_UUID), anyOrNull()) } doReturn messagePartDirectory
+    }
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val attachmentFileManager = AttachmentFileManager(storageManager, ACCOUNT_UUID)
+    private val threadMessageOperations = ThreadMessageOperations()
+    private val copyMessageOperations = CopyMessageOperations(
+        lockableDatabase,
+        attachmentFileManager,
+        threadMessageOperations
+    )
+
+    @After
+    fun tearDown() {
+        messagePartDirectory.deleteRecursively()
+    }
+
+    @Test
+    fun `copy message that is part of a thread`() {
+        val sourceMessagePartId1 = sqliteDatabase.createMessagePart(
+            seq = 0,
+            dataLocation = DataLocation.CHILD_PART_CONTAINS_DATA,
+            mimeType = "multipart/mixed",
+            boundary = "--boundary",
+            header = "Message-ID: <msg0002@domain.example>\nIn-Reply-To: <msg0001@domain.example>\n".crlf()
+        )
+        val sourceMessagePartId2 = sqliteDatabase.createMessagePart(
+            seq = 1,
+            root = sourceMessagePartId1,
+            parent = sourceMessagePartId1,
+            mimeType = "text/plain",
+            dataLocation = DataLocation.IN_DATABASE,
+            data = "Text part".toByteArray()
+        )
+        val sourceMessagePartId3 = sqliteDatabase.createMessagePart(
+            seq = 2,
+            root = sourceMessagePartId1,
+            parent = sourceMessagePartId1,
+            mimeType = "application/octet-stream",
+            dataLocation = DataLocation.ON_DISK
+        )
+        attachmentFileManager.getAttachmentFile(sourceMessagePartId3).sink().buffer().use { sink ->
+            sink.writeUtf8("Part contents")
+        }
+
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = true,
+            messageIdHeader = "<msg0001@domain.example>"
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = false,
+            messageIdHeader = "<msg0002@domain.example>",
+            messagePartId = sourceMessagePartId1
+        )
+        val messageId3 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = false,
+            messageIdHeader = "<msg0003@domain.example>"
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val threadId2 = sqliteDatabase.createThread(messageId2, root = threadId1, parent = threadId1)
+        val threadId3 = sqliteDatabase.createThread(messageId3, root = threadId1, parent = threadId2)
+
+        val destinationMessageId = copyMessageOperations.copyMessage(messageId = messageId2, destinationFolderId = 2)
+
+        assertThat(destinationMessageId).isNotIn(setOf(messageId1, messageId2, messageId3))
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(3 + 2)
+
+        val destinationMessageThread = threads.first { it.messageId == destinationMessageId }
+        assertThat(destinationMessageThread.id).isNotIn(setOf(threadId1, threadId2, threadId3))
+        assertThat(destinationMessageThread.parent).isEqualTo(destinationMessageThread.root)
+
+        val destinationRootThread = threads.first { it.id == destinationMessageThread.root }
+        assertThat(destinationRootThread.messageId).isNotIn(setOf(messageId1, messageId2, messageId3))
+        assertThat(destinationRootThread.root).isEqualTo(destinationRootThread.id)
+        assertThat(destinationRootThread.parent).isNull()
+
+        val messages = sqliteDatabase.readMessages()
+        val destinationRootThreadMessage = messages.first { it.id == destinationRootThread.messageId }
+        assertThat(destinationRootThreadMessage.empty).isEqualTo(1)
+        assertThat(destinationRootThreadMessage.folderId).isEqualTo(2)
+        assertThat(destinationRootThreadMessage.messageId).isEqualTo("<msg0001@domain.example>")
+
+        val destinationMessage = messages.first { it.id == destinationMessageThread.messageId }
+        val sourceMessage = messages.first { it.id == messageId2 }
+        assertThat(destinationMessage).isEqualTo(
+            sourceMessage.copy(
+                id = destinationMessageId,
+                uid = destinationMessage.uid,
+                folderId = 2,
+                messagePartId = destinationMessage.messagePartId
+            )
+        )
+
+        val messageParts = sqliteDatabase.readMessageParts()
+        assertThat(messageParts).hasSize(3 + 3)
+
+        val sourceMessagePart1 = messageParts.first { it.id == sourceMessagePartId1 }
+        val sourceMessagePart2 = messageParts.first { it.id == sourceMessagePartId2 }
+        val sourceMessagePart3 = messageParts.first { it.id == sourceMessagePartId3 }
+        val destinationMessagePart1 = messageParts.first { it.id == destinationMessage.messagePartId }
+        val destinationMessagePart2 = messageParts.first { it.root == destinationMessage.messagePartId && it.seq == 1 }
+        val destinationMessagePart3 = messageParts.first { it.root == destinationMessage.messagePartId && it.seq == 2 }
+        assertThat(destinationMessagePart1).isNotIn(setOf(sourceMessagePart1, sourceMessagePart2, sourceMessagePart3))
+        assertThat(destinationMessagePart1).isEqualTo(
+            sourceMessagePart1.copy(
+                id = destinationMessagePart1.id,
+                root = destinationMessagePart1.id,
+                parent = -1
+            )
+        )
+        assertThat(destinationMessagePart2).isNotIn(setOf(sourceMessagePart1, sourceMessagePart2, sourceMessagePart3))
+        assertThat(destinationMessagePart2).isEqualTo(
+            sourceMessagePart2.copy(
+                id = destinationMessagePart2.id,
+                root = destinationMessagePart1.id,
+                parent = destinationMessagePart1.id
+            )
+        )
+        assertThat(destinationMessagePart3).isNotIn(setOf(sourceMessagePart1, sourceMessagePart2, sourceMessagePart3))
+        assertThat(destinationMessagePart3).isEqualTo(
+            sourceMessagePart3.copy(
+                id = destinationMessagePart3.id,
+                root = destinationMessagePart1.id,
+                parent = destinationMessagePart1.id
+            )
+        )
+
+        val files = messagePartDirectory.list()?.toList() ?: emptyList()
+        assertThat(files).hasSize(2)
+
+        attachmentFileManager.getAttachmentFile(destinationMessagePart3.id!!).source().buffer().use { source ->
+            assertThat(source.readUtf8()).isEqualTo("Part contents")
+        }
+    }
+
+    @Test
+    fun `copy message into an existing thread`() {
+        val sourceMessagePartId = sqliteDatabase.createMessagePart(
+            header = "Message-ID: <msg0002@domain.example>\nIn-Reply-To: <msg0001@domain.example>\n".crlf(),
+            mimeType = "text/plain",
+            dataLocation = DataLocation.IN_DATABASE,
+            data = "Text part".toByteArray()
+        )
+        attachmentFileManager.getAttachmentFile(sourceMessagePartId).sink().buffer().use { sink ->
+            sink.writeUtf8("Part contents")
+        }
+
+        val sourceMessageId = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = false,
+            messageIdHeader = "<msg0002@domain.example>",
+            messagePartId = sourceMessagePartId
+        )
+        val destinationMessageId = sqliteDatabase.createMessage(
+            folderId = 2,
+            empty = true,
+            messageIdHeader = "<msg0002@domain.example>"
+        )
+        val otherDestinationMessageId = sqliteDatabase.createMessage(
+            folderId = 2,
+            empty = false,
+            messageIdHeader = "<msg0003@domain.example>"
+        )
+        val destinationThreadId = sqliteDatabase.createThread(destinationMessageId)
+        val otherDestinationThreadId = sqliteDatabase.createThread(
+            otherDestinationMessageId,
+            root = destinationThreadId,
+            parent = destinationThreadId
+        )
+
+        val resultMessageId = copyMessageOperations.copyMessage(messageId = sourceMessageId, destinationFolderId = 2)
+
+        assertThat(resultMessageId).isEqualTo(destinationMessageId)
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(2 + 1)
+
+        val destinationThread = threads.first { it.messageId == destinationMessageId }
+        assertThat(destinationThread.id).isEqualTo(destinationThreadId)
+        assertThat(destinationThread.parent).isEqualTo(destinationThread.root)
+
+        val destinationRootThread = threads.first { it.id == destinationThread.root }
+        assertThat(destinationRootThread.root).isEqualTo(destinationRootThread.id)
+        assertThat(destinationRootThread.parent).isNull()
+
+        val otherDestinationThread = threads.first { it.id == otherDestinationThreadId }
+        assertThat(otherDestinationThread.root).isEqualTo(destinationRootThread.id)
+        assertThat(otherDestinationThread.parent).isEqualTo(destinationThread.id)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(3 + 1)
+
+        val destinationRootThreadMessage = messages.first { it.id == destinationRootThread.messageId }
+        assertThat(destinationRootThreadMessage.empty).isEqualTo(1)
+        assertThat(destinationRootThreadMessage.folderId).isEqualTo(2)
+        assertThat(destinationRootThreadMessage.messageId).isEqualTo("<msg0001@domain.example>")
+
+        val destinationMessage = messages.first { it.id == destinationMessageId }
+        val sourceMessage = messages.first { it.id == sourceMessageId }
+        assertThat(destinationMessage).isEqualTo(
+            sourceMessage.copy(
+                id = destinationMessageId,
+                uid = destinationMessage.uid,
+                folderId = 2,
+                messagePartId = destinationMessage.messagePartId
+            )
+        )
+
+        val messageParts = sqliteDatabase.readMessageParts()
+        assertThat(messageParts).hasSize(1 + 1)
+
+        val sourceMessagePart = messageParts.first { it.id == sourceMessagePartId }
+        val destinationMessagePart = messageParts.first { it.id == destinationMessage.messagePartId }
+        assertThat(destinationMessagePart).isEqualTo(
+            sourceMessagePart.copy(
+                id = destinationMessagePart.id,
+                root = destinationMessagePart.id,
+                parent = -1
+            )
+        )
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/CreateFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/CreateFolderOperationsTest.kt
new file mode 100644
index 0000000..d3af642
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/CreateFolderOperationsTest.kt
@@ -0,0 +1,91 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.FolderClass
+import com.fsck.k9.mail.FolderType
+import com.fsck.k9.mailstore.CreateFolderInfo
+import com.fsck.k9.mailstore.FolderSettings
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class CreateFolderOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val createFolderOperations = CreateFolderOperations(lockableDatabase)
+
+    @Test
+    fun `create single folder`() {
+        createFolderOperations.createFolders(
+            listOf(
+                CreateFolderInfo(
+                    serverId = "archived_messages",
+                    name = "Archive",
+                    type = FolderType.ARCHIVE,
+                    settings = FolderSettings(
+                        visibleLimit = 10,
+                        displayClass = FolderClass.FIRST_CLASS,
+                        syncClass = FolderClass.SECOND_CLASS,
+                        notifyClass = FolderClass.NO_CLASS,
+                        pushClass = FolderClass.NO_CLASS,
+                        inTopGroup = true,
+                        integrate = false
+                    )
+                )
+            )
+        )
+
+        val folders = sqliteDatabase.readFolders()
+        assertThat(folders).hasSize(1)
+        val folder = folders.first()
+        assertThat(folder.serverId).isEqualTo("archived_messages")
+        assertThat(folder.name).isEqualTo("Archive")
+        assertThat(folder.type).isEqualTo("archive")
+        assertThat(folder.visibleLimit).isEqualTo(10)
+        assertThat(folder.displayClass).isEqualTo("FIRST_CLASS")
+        assertThat(folder.syncClass).isEqualTo("SECOND_CLASS")
+        assertThat(folder.notifyClass).isEqualTo("NO_CLASS")
+        assertThat(folder.pushClass).isEqualTo("NO_CLASS")
+        assertThat(folder.inTopGroup).isEqualTo(1)
+        assertThat(folder.integrate).isEqualTo(0)
+    }
+
+    @Test
+    fun `create multiple folders`() {
+        createFolderOperations.createFolders(
+            listOf(
+                createCreateFolderInfo(serverId = "folder1", name = "Inbox"),
+                createCreateFolderInfo(serverId = "folder2", name = "Sent"),
+                createCreateFolderInfo(serverId = "folder3", name = "Trash")
+            )
+        )
+
+        val folders = sqliteDatabase.readFolders()
+        assertThat(folders).hasSize(3)
+        assertThat(folders.map { it.serverId to it.name }.toSet()).isEqualTo(
+            setOf(
+                "folder1" to "Inbox",
+                "folder2" to "Sent",
+                "folder3" to "Trash"
+            )
+        )
+    }
+
+    fun createCreateFolderInfo(serverId: String, name: String): CreateFolderInfo {
+        return CreateFolderInfo(
+            serverId = serverId,
+            name = name,
+            type = FolderType.REGULAR,
+            settings = FolderSettings(
+                visibleLimit = 25,
+                displayClass = FolderClass.NO_CLASS,
+                syncClass = FolderClass.INHERITED,
+                notifyClass = FolderClass.INHERITED,
+                pushClass = FolderClass.NO_CLASS,
+                inTopGroup = false,
+                integrate = false
+            )
+        )
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/DeleteFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/DeleteFolderOperationsTest.kt
new file mode 100644
index 0000000..9726ec4
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/DeleteFolderOperationsTest.kt
@@ -0,0 +1,62 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import com.fsck.k9.mailstore.StorageManager
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.After
+import org.junit.Test
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+
+private const val ACCOUNT_UUID = "00000000-0000-4000-0000-000000000000"
+
+class DeleteFolderOperationsTest : RobolectricTest() {
+    private val messagePartDirectory = createRandomTempDirectory()
+    private val sqliteDatabase = createDatabase()
+    private val storageManager = mock<StorageManager> {
+        on { getAttachmentDirectory(eq(ACCOUNT_UUID), anyOrNull()) } doReturn messagePartDirectory
+    }
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val attachmentFileManager = AttachmentFileManager(storageManager, ACCOUNT_UUID)
+    private val deleteFolderOperations = DeleteFolderOperations(lockableDatabase, attachmentFileManager)
+
+    @After
+    fun tearDown() {
+        messagePartDirectory.deleteRecursively()
+    }
+
+    @Test
+    fun `delete folder should remove message part files`() {
+        createFolderWithMessage("delete", "message1")
+        val messagePartId = createFolderWithMessage("retain", "message2")
+
+        deleteFolderOperations.deleteFolders(listOf("delete"))
+
+        val folders = sqliteDatabase.readFolders()
+        assertThat(folders).hasSize(1)
+        assertThat(folders.first().serverId).isEqualTo("retain")
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+        assertThat(messages.first().uid).isEqualTo("message2")
+
+        val messagePartFiles = messagePartDirectory.listFiles()
+        assertThat(messagePartFiles).isNotNull()
+            .extracting { it.name }.containsExactly(messagePartId.toString())
+    }
+
+    private fun createFolderWithMessage(folderServerId: String, messageServerId: String): Long {
+        val folderId = sqliteDatabase.createFolder(serverId = folderServerId)
+        val messagePartId = sqliteDatabase.createMessagePart(dataLocation = 2, directory = messagePartDirectory)
+        sqliteDatabase.createMessage(folderId = folderId, uid = messageServerId, messagePartId = messagePartId)
+
+        return messagePartId
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/DeleteMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/DeleteMessageOperationsTest.kt
new file mode 100644
index 0000000..68425e7
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/DeleteMessageOperationsTest.kt
@@ -0,0 +1,196 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import com.fsck.k9.mailstore.StorageManager
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.After
+import org.junit.Test
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+
+private const val ACCOUNT_UUID = "00000000-0000-4000-0000-000000000000"
+
+class DeleteMessageOperationsTest : RobolectricTest() {
+    private val messagePartDirectory = createRandomTempDirectory()
+    private val sqliteDatabase = createDatabase()
+    private val storageManager = mock<StorageManager> {
+        on { getAttachmentDirectory(eq(ACCOUNT_UUID), anyOrNull()) } doReturn messagePartDirectory
+    }
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val attachmentFileManager = AttachmentFileManager(storageManager, ACCOUNT_UUID)
+    private val deleteMessageOperations = DeleteMessageOperations(lockableDatabase, attachmentFileManager)
+
+    @After
+    fun tearDown() {
+        messagePartDirectory.deleteRecursively()
+    }
+
+    @Test
+    fun `destroy message with empty parent messages`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "empty1",
+            empty = true,
+            messageIdHeader = "msg001@domain.example"
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "empty2",
+            empty = true,
+            messageIdHeader = "msg002@domain.example"
+        )
+        val messageId3 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "delete",
+            empty = false,
+            messageIdHeader = "msg003@domain.example"
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId = messageId1)
+        val threadId2 = sqliteDatabase.createThread(messageId = messageId2, root = threadId1, parent = threadId1)
+        sqliteDatabase.createThread(messageId = messageId3, root = threadId1, parent = threadId2)
+
+        deleteMessageOperations.destroyMessages(folderId = folderId, messageServerIds = listOf("delete"))
+
+        assertThat(sqliteDatabase.readMessages()).isEmpty()
+        assertThat(sqliteDatabase.readThreads()).isEmpty()
+    }
+
+    @Test
+    fun `destroy message with empty parent message that has another child`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "empty",
+            empty = true,
+            messageIdHeader = "msg001@domain.example"
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "child1",
+            empty = false,
+            messageIdHeader = "msg002@domain.example"
+        )
+        val messageId3 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "delete",
+            empty = false,
+            messageIdHeader = "msg003@domain.example"
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId = messageId1)
+        val threadId2 = sqliteDatabase.createThread(messageId = messageId2, root = threadId1, parent = threadId1)
+        sqliteDatabase.createThread(messageId = messageId3, root = threadId1, parent = threadId1)
+
+        deleteMessageOperations.destroyMessages(folderId = folderId, messageServerIds = listOf("delete"))
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(2)
+        assertThat(messages.map { it.id }.toSet()).isEqualTo(setOf(messageId1, messageId2))
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(2)
+        assertThat(threads.map { it.id }.toSet()).isEqualTo(setOf(threadId1, threadId2))
+    }
+
+    @Test
+    fun `destroy message with non-empty parent message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "parent",
+            empty = false,
+            messageIdHeader = "msg001@domain.example"
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "delete",
+            empty = false,
+            messageIdHeader = "msg002@domain.example"
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId = messageId1)
+        sqliteDatabase.createThread(messageId = messageId2, root = threadId1, parent = threadId1)
+
+        deleteMessageOperations.destroyMessages(folderId = folderId, messageServerIds = listOf("delete"))
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+        assertThat(messages.first().id).isEqualTo(messageId1)
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(1)
+        assertThat(threads.first().id).isEqualTo(threadId1)
+    }
+
+    @Test
+    fun `destroy message without parent message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "delete",
+            empty = false,
+            messageIdHeader = "msg001@domain.example"
+        )
+        sqliteDatabase.createThread(messageId = messageId1)
+
+        deleteMessageOperations.destroyMessages(folderId = folderId, messageServerIds = listOf("delete"))
+
+        assertThat(sqliteDatabase.readMessages()).isEmpty()
+        assertThat(sqliteDatabase.readThreads()).isEmpty()
+    }
+
+    @Test
+    fun `destroy message with child message should convert to empty message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "delete",
+            empty = false,
+            messageIdHeader = "msg001@domain.example"
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = folderId,
+            uid = "child",
+            empty = false,
+            messageIdHeader = "msg002@domain.example"
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId = messageId1)
+        val threadId2 = sqliteDatabase.createThread(messageId = messageId2, root = threadId1, parent = threadId1)
+
+        deleteMessageOperations.destroyMessages(folderId = folderId, messageServerIds = listOf("delete"))
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(2)
+        val message1 = messages.first { it.id == messageId1 }
+        assertThat(message1.empty).isEqualTo(1)
+        assertThat(message1.subject).isNull()
+        assertThat(message1.date).isNull()
+        assertThat(message1.flags).isNull()
+        assertThat(message1.senderList).isNull()
+        assertThat(message1.toList).isNull()
+        assertThat(message1.ccList).isNull()
+        assertThat(message1.bccList).isNull()
+        assertThat(message1.replyToList).isNull()
+        assertThat(message1.attachmentCount).isNull()
+        assertThat(message1.internalDate).isNull()
+        assertThat(message1.previewType).isEqualTo("none")
+        assertThat(message1.preview).isNull()
+        assertThat(message1.mimeType).isNull()
+        assertThat(message1.normalizedSubjectHash).isNull()
+        assertThat(message1.messagePartId).isNull()
+        assertThat(message1.encryptionType).isNull()
+        assertThat(messages.firstOrNull { it.id == messageId2 }).isNotNull()
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(2)
+        assertThat(threads).extracting { it.id }.containsExactlyInAnyOrder(threadId1, threadId2)
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/FileHelpers.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/FileHelpers.kt
new file mode 100644
index 0000000..b78ff32
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/FileHelpers.kt
@@ -0,0 +1,10 @@
+package com.fsck.k9.storage.messages
+
+import java.io.File
+import java.util.UUID
+
+@Suppress("NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS")
+fun createRandomTempDirectory(): File {
+    val tempDirectory = File(System.getProperty("java.io.tmpdir", "."))
+    return File(tempDirectory, UUID.randomUUID().toString()).also { it.mkdir() }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/FlagMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/FlagMessageOperationsTest.kt
new file mode 100644
index 0000000..8438694
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/FlagMessageOperationsTest.kt
@@ -0,0 +1,100 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isTrue
+import com.fsck.k9.mail.Flag
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class FlagMessageOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val flagMessageOperations = FlagMessageOperations(lockableDatabase)
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `empty messageIds list`() {
+        flagMessageOperations.setFlag(emptyList(), Flag.SEEN, true)
+    }
+
+    @Test
+    fun `mark one message as answered`() {
+        val messageId = sqliteDatabase.createMessage(folderId = 1, uid = "uid1", answered = false)
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid2", answered = false)
+        val messageIds = listOf(messageId)
+
+        flagMessageOperations.setFlag(messageIds, Flag.ANSWERED, true)
+
+        val messages = sqliteDatabase.readMessages()
+
+        val message = messages.find { it.id == messageId } ?: error("Original message not found")
+        assertThat(message.answered).isEqualTo(1)
+
+        val otherMessages = messages.filterNot { it.id == messageId }
+        assertThat(otherMessages).hasSize(1)
+        assertThat(otherMessages.all { it.answered == 0 }).isTrue()
+    }
+
+    @Test
+    fun `mark multiple messages as read`() {
+        val messageId1 = sqliteDatabase.createMessage(folderId = 1, uid = "uid1", read = false)
+        val messageId2 = sqliteDatabase.createMessage(folderId = 1, uid = "uid2", read = false)
+        val messageId3 = sqliteDatabase.createMessage(folderId = 1, uid = "uid3", read = false)
+        sqliteDatabase.createMessage(folderId = 1, uid = "uidx", read = false)
+        val messageIds = listOf(messageId1, messageId2, messageId3)
+
+        flagMessageOperations.setFlag(messageIds, Flag.SEEN, true)
+
+        val messages = sqliteDatabase.readMessages()
+
+        val affectedMessages = messages.filter { it.id in messageIds }
+        assertThat(affectedMessages).hasSize(3)
+        assertThat(affectedMessages.all { it.read == 1 }).isTrue()
+
+        val otherMessages = messages.filterNot { it.id in messageIds }
+        assertThat(otherMessages).hasSize(1)
+        assertThat(otherMessages.all { it.read == 0 }).isTrue()
+    }
+
+    @Test
+    fun `mark message as read`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", read = false)
+
+        flagMessageOperations.setMessageFlag(folderId = 1, messageServerId = "uid1", Flag.SEEN, true)
+
+        val message = sqliteDatabase.readMessages().first()
+        assertThat(message.read).isEqualTo(1)
+    }
+
+    @Test
+    fun `mark message as unread`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", read = true)
+
+        flagMessageOperations.setMessageFlag(folderId = 1, messageServerId = "uid1", Flag.SEEN, false)
+
+        val message = sqliteDatabase.readMessages().first()
+        assertThat(message.read).isEqualTo(0)
+    }
+
+    @Test
+    fun `mark message as X_DOWNLOADED_FULL`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", flags = "X_SUBJECT_DECRYPTED")
+
+        flagMessageOperations.setMessageFlag(folderId = 1, messageServerId = "uid1", Flag.X_DOWNLOADED_FULL, true)
+
+        val message = sqliteDatabase.readMessages().first()
+        val readFlags = message.flags!!.split(',').toSet()
+        assertThat(readFlags).isEqualTo(setOf("X_SUBJECT_DECRYPTED", "X_DOWNLOADED_FULL"))
+    }
+
+    @Test
+    fun `remove X_DOWNLOADED_FULL flag`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", flags = "X_DOWNLOADED_FULL")
+
+        flagMessageOperations.setMessageFlag(folderId = 1, messageServerId = "uid1", Flag.X_DOWNLOADED_FULL, false)
+
+        val message = sqliteDatabase.readMessages().first()
+        assertThat(message.flags).isEqualTo("")
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/FolderHelpers.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/FolderHelpers.kt
new file mode 100644
index 0000000..64fd21e
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/FolderHelpers.kt
@@ -0,0 +1,95 @@
+package com.fsck.k9.storage.messages
+
+import android.content.ContentValues
+import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.android.common.database.getIntOrNull
+import app.k9mail.core.android.common.database.getLongOrNull
+import app.k9mail.core.android.common.database.getStringOrNull
+import app.k9mail.core.android.common.database.map
+
+fun SQLiteDatabase.createFolder(
+    name: String = "irrelevant",
+    type: String = "regular",
+    serverId: String? = null,
+    isLocalOnly: Boolean = true,
+    integrate: Boolean = false,
+    inTopGroup: Boolean = false,
+    displayClass: String = "NO_CLASS",
+    syncClass: String? = "INHERITED",
+    notifyClass: String? = "INHERITED",
+    pushClass: String? = "SECOND_CLASS",
+    lastUpdated: Long = 0L,
+    unreadCount: Int = 0,
+    visibleLimit: Int = 25,
+    status: String? = null,
+    flaggedCount: Int = 0,
+    moreMessages: String = "unknown"
+): Long {
+    val values = ContentValues().apply {
+        put("name", name)
+        put("type", type)
+        put("server_id", serverId)
+        put("local_only", isLocalOnly)
+        put("integrate", integrate)
+        put("top_group", inTopGroup)
+        put("display_class", displayClass)
+        put("poll_class", syncClass)
+        put("notify_class", notifyClass)
+        put("push_class", pushClass)
+        put("last_updated", lastUpdated)
+        put("unread_count", unreadCount)
+        put("visible_limit", visibleLimit)
+        put("status", status)
+        put("flagged_count", flaggedCount)
+        put("more_messages", moreMessages)
+    }
+
+    return insert("folders", null, values)
+}
+
+fun SQLiteDatabase.readFolders(): List<FolderEntry> {
+    val cursor = rawQuery("SELECT * FROM folders", null)
+    return cursor.use {
+        cursor.map {
+            FolderEntry(
+                id = cursor.getLongOrNull("id"),
+                name = cursor.getStringOrNull("name"),
+                type = cursor.getStringOrNull("type"),
+                serverId = cursor.getStringOrNull("server_id"),
+                isLocalOnly = cursor.getIntOrNull("local_only"),
+                integrate = cursor.getIntOrNull("integrate"),
+                inTopGroup = cursor.getIntOrNull("top_group"),
+                displayClass = cursor.getStringOrNull("display_class"),
+                syncClass = cursor.getStringOrNull("poll_class"),
+                notifyClass = cursor.getStringOrNull("notify_class"),
+                pushClass = cursor.getStringOrNull("push_class"),
+                lastUpdated = cursor.getLongOrNull("last_updated"),
+                unreadCount = cursor.getIntOrNull("unread_count"),
+                visibleLimit = cursor.getIntOrNull("visible_limit"),
+                status = cursor.getStringOrNull("status"),
+                flaggedCount = cursor.getIntOrNull("flagged_count"),
+                moreMessages = cursor.getStringOrNull("more_messages")
+            )
+        }
+    }
+}
+
+data class FolderEntry(
+    val id: Long?,
+    val name: String?,
+    val type: String?,
+    val serverId: String?,
+    val isLocalOnly: Int?,
+    val integrate: Int?,
+    val inTopGroup: Int?,
+    val displayClass: String?,
+    val syncClass: String?,
+    val notifyClass: String?,
+    val pushClass: String?,
+    val lastUpdated: Long?,
+    val unreadCount: Int?,
+    val visibleLimit: Int?,
+    val status: String?,
+    val flaggedCount: Int?,
+    val moreMessages: String?
+)
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/KeyValueHelpers.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/KeyValueHelpers.kt
new file mode 100644
index 0000000..5af9132
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/KeyValueHelpers.kt
@@ -0,0 +1,77 @@
+package com.fsck.k9.storage.messages
+
+import android.content.ContentValues
+import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.android.common.database.getLongOrNull
+import app.k9mail.core.android.common.database.getStringOrNull
+import app.k9mail.core.android.common.database.map
+
+fun SQLiteDatabase.createExtraValue(
+    name: String = "irrelevant",
+    text: String? = null,
+    number: Long? = null
+): Long {
+    val values = ContentValues().apply {
+        put("name", name)
+        put("value_text", text)
+        put("value_integer", number)
+    }
+
+    return insert("account_extra_values", null, values)
+}
+
+fun SQLiteDatabase.readExtraValues(): List<ExtraValueEntry> {
+    val cursor = rawQuery("SELECT * FROM account_extra_values", null)
+    return cursor.use {
+        cursor.map {
+            ExtraValueEntry(
+                name = cursor.getStringOrNull("name"),
+                text = cursor.getStringOrNull("value_text"),
+                number = cursor.getLongOrNull("value_integer")
+            )
+        }
+    }
+}
+
+data class ExtraValueEntry(
+    val name: String?,
+    val text: String?,
+    val number: Long?
+)
+
+fun SQLiteDatabase.createFolderExtraValue(
+    folderId: Long,
+    name: String = "irrelevant",
+    text: String? = null,
+    number: Long? = null
+): Long {
+    val values = ContentValues().apply {
+        put("folder_id", folderId)
+        put("name", name)
+        put("value_text", text)
+        put("value_integer", number)
+    }
+
+    return insert("folder_extra_values", null, values)
+}
+
+fun SQLiteDatabase.readFolderExtraValues(): List<FolderExtraValueEntry> {
+    val cursor = rawQuery("SELECT * FROM folder_extra_values", null)
+    return cursor.use {
+        cursor.map {
+            FolderExtraValueEntry(
+                folderId = cursor.getLongOrNull("folder_id"),
+                name = cursor.getStringOrNull("name"),
+                text = cursor.getStringOrNull("value_text"),
+                number = cursor.getLongOrNull("value_integer")
+            )
+        }
+    }
+}
+
+data class FolderExtraValueEntry(
+    val folderId: Long?,
+    val name: String?,
+    val text: String?,
+    val number: Long?
+)
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/KeyValueStoreOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/KeyValueStoreOperationsTest.kt
new file mode 100644
index 0000000..f31c591
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/KeyValueStoreOperationsTest.kt
@@ -0,0 +1,210 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class KeyValueStoreOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val keyValueStoreOperations = KeyValueStoreOperations(lockableDatabase)
+
+    @Test
+    fun `get extra string`() {
+        sqliteDatabase.createExtraValue(name = "test", text = "Wurstsalat")
+
+        val result = keyValueStoreOperations.getExtraString("test")
+
+        assertThat(result).isEqualTo("Wurstsalat")
+    }
+
+    @Test
+    fun `get non-existent extra string`() {
+        val result = keyValueStoreOperations.getExtraString("test")
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `create extra string`() {
+        keyValueStoreOperations.setExtraString("jmapState", "ABC42")
+
+        val extraValues = sqliteDatabase.readExtraValues()
+        assertThat(extraValues).hasSize(1)
+        assertThat(extraValues.first()).isEqualTo(
+            ExtraValueEntry(
+                name = "jmapState",
+                text = "ABC42",
+                number = null
+            )
+        )
+    }
+
+    @Test
+    fun `update extra string`() {
+        sqliteDatabase.createExtraValue(name = "jmapState", text = "XYZ23")
+
+        keyValueStoreOperations.setExtraString("jmapState", "ABC42")
+
+        val extraValues = sqliteDatabase.readExtraValues()
+        assertThat(extraValues).hasSize(1)
+        assertThat(extraValues.first()).isEqualTo(
+            ExtraValueEntry(
+                name = "jmapState",
+                text = "ABC42",
+                number = null
+            )
+        )
+    }
+
+    @Test
+    fun `get extra number`() {
+        sqliteDatabase.createExtraValue(name = "test", number = 23)
+
+        val result = keyValueStoreOperations.getExtraNumber("test")
+
+        assertThat(result).isEqualTo(23)
+    }
+
+    @Test
+    fun `get non-existent extra number`() {
+        val result = keyValueStoreOperations.getExtraNumber("test")
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `create extra number`() {
+        keyValueStoreOperations.setExtraNumber("lastChanged", 123L)
+
+        val extraValues = sqliteDatabase.readExtraValues()
+        assertThat(extraValues).hasSize(1)
+        assertThat(extraValues.first()).isEqualTo(
+            ExtraValueEntry(
+                name = "lastChanged",
+                text = null,
+                number = 123L
+            )
+        )
+    }
+
+    @Test
+    fun `update extra number`() {
+        sqliteDatabase.createExtraValue(name = "lastChanged", number = 0L)
+
+        keyValueStoreOperations.setExtraNumber("lastChanged", 42L)
+
+        val extraValues = sqliteDatabase.readExtraValues()
+        assertThat(extraValues).hasSize(1)
+        assertThat(extraValues.first()).isEqualTo(
+            ExtraValueEntry(
+                name = "lastChanged",
+                text = null,
+                number = 42
+            )
+        )
+    }
+
+    @Test
+    fun `get extra folder string`() {
+        sqliteDatabase.createFolderExtraValue(folderId = 1, name = "test", text = "Wurstsalat")
+
+        val result = keyValueStoreOperations.getFolderExtraString(folderId = 1, name = "test")
+
+        assertThat(result).isEqualTo("Wurstsalat")
+    }
+
+    @Test
+    fun `get non-existent extra folder string`() {
+        val result = keyValueStoreOperations.getFolderExtraString(folderId = 1, name = "test")
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `create extra folder string`() {
+        keyValueStoreOperations.setFolderExtraString(folderId = 1, name = "imapUidValidity", value = "1")
+
+        val folderExtraValues = sqliteDatabase.readFolderExtraValues()
+        assertThat(folderExtraValues).hasSize(1)
+        assertThat(folderExtraValues.first()).isEqualTo(
+            FolderExtraValueEntry(
+                folderId = 1,
+                name = "imapUidValidity",
+                text = "1",
+                number = null
+            )
+        )
+    }
+
+    @Test
+    fun `update extra folder string`() {
+        sqliteDatabase.createFolderExtraValue(folderId = 1, name = "imapUidValidity", text = "23")
+
+        keyValueStoreOperations.setFolderExtraString(folderId = 1, name = "imapUidValidity", value = "42")
+
+        val folderExtraValues = sqliteDatabase.readFolderExtraValues()
+        assertThat(folderExtraValues).hasSize(1)
+        assertThat(folderExtraValues.first()).isEqualTo(
+            FolderExtraValueEntry(
+                folderId = 1,
+                name = "imapUidValidity",
+                text = "42",
+                number = null
+            )
+        )
+    }
+
+    @Test
+    fun `get extra folder number`() {
+        sqliteDatabase.createFolderExtraValue(folderId = 1, name = "test", number = 23)
+
+        val result = keyValueStoreOperations.getFolderExtraNumber(folderId = 1, name = "test")
+
+        assertThat(result).isEqualTo(23)
+    }
+
+    @Test
+    fun `get non-existent extra folder number`() {
+        val result = keyValueStoreOperations.getFolderExtraNumber(folderId = 1, name = "test")
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `create extra folder number`() {
+        keyValueStoreOperations.setFolderExtraNumber(folderId = 1, name = "lastChanged", value = 123L)
+
+        val folderExtraValues = sqliteDatabase.readFolderExtraValues()
+        assertThat(folderExtraValues).hasSize(1)
+        assertThat(folderExtraValues.first()).isEqualTo(
+            FolderExtraValueEntry(
+                folderId = 1,
+                name = "lastChanged",
+                text = null,
+                number = 123L
+            )
+        )
+    }
+
+    @Test
+    fun `update extra folder number`() {
+        sqliteDatabase.createFolderExtraValue(folderId = 1, name = "lastChanged", number = 0L)
+
+        keyValueStoreOperations.setFolderExtraNumber(folderId = 1, name = "lastChanged", value = 42L)
+
+        val folderExtraValues = sqliteDatabase.readFolderExtraValues()
+        assertThat(folderExtraValues).hasSize(1)
+        assertThat(folderExtraValues.first()).isEqualTo(
+            FolderExtraValueEntry(
+                folderId = 1,
+                name = "lastChanged",
+                text = null,
+                number = 42
+            )
+        )
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/MessageDatabaseHelpers.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/MessageDatabaseHelpers.kt
new file mode 100644
index 0000000..6ccbdbf
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/MessageDatabaseHelpers.kt
@@ -0,0 +1,213 @@
+package com.fsck.k9.storage.messages
+
+import android.content.ContentValues
+import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.android.common.database.getIntOrNull
+import app.k9mail.core.android.common.database.getLongOrNull
+import app.k9mail.core.android.common.database.getStringOrNull
+import app.k9mail.core.android.common.database.map
+import com.fsck.k9.mailstore.DatabasePreviewType
+import com.fsck.k9.mailstore.LockableDatabase
+import com.fsck.k9.mailstore.MigrationsHelper
+import com.fsck.k9.storage.K9SchemaDefinitionFactory
+import java.io.File
+import org.mockito.ArgumentMatchers
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.mock
+
+fun createLockableDatabaseMock(sqliteDatabase: SQLiteDatabase): LockableDatabase {
+    return mock {
+        on { execute(ArgumentMatchers.anyBoolean(), any<LockableDatabase.DbCallback<Any>>()) } doAnswer { stubbing ->
+            val callback: LockableDatabase.DbCallback<Any> = stubbing.getArgument(1)
+            callback.doDbWork(sqliteDatabase)
+        }
+    }
+}
+
+fun createDatabase(): SQLiteDatabase {
+    val migrationsHelper = mock<MigrationsHelper>()
+
+    val sqliteDatabase = SQLiteDatabase.create(null)
+    val schemaDefinitionFactory = K9SchemaDefinitionFactory()
+    val schemaDefinition = schemaDefinitionFactory.createSchemaDefinition(migrationsHelper)
+
+    schemaDefinition.doDbUpgrade(sqliteDatabase)
+
+    return sqliteDatabase
+}
+
+fun SQLiteDatabase.createMessage(
+    folderId: Long,
+    deleted: Boolean = false,
+    uid: String? = null,
+    subject: String = "",
+    date: Long = 0L,
+    flags: String = "",
+    senderList: String = "",
+    toList: String = "",
+    ccList: String = "",
+    bccList: String = "",
+    replyToList: String = "",
+    attachmentCount: Int = 0,
+    internalDate: Long = 0L,
+    messageIdHeader: String? = null,
+    previewType: DatabasePreviewType = DatabasePreviewType.NONE,
+    preview: String = "",
+    mimeType: String = "text/plain",
+    normalizedSubjectHash: Long = 0L,
+    empty: Boolean = false,
+    read: Boolean = false,
+    flagged: Boolean = false,
+    answered: Boolean = false,
+    forwarded: Boolean = false,
+    messagePartId: Long = 0L,
+    encryptionType: String? = null,
+    newMessage: Boolean = false
+): Long {
+    val values = ContentValues().apply {
+        put("deleted", if (deleted) 1 else 0)
+        put("folder_id", folderId)
+        put("uid", uid)
+        put("subject", subject)
+        put("date", date)
+        put("flags", flags)
+        put("sender_list", senderList)
+        put("to_list", toList)
+        put("cc_list", ccList)
+        put("bcc_list", bccList)
+        put("reply_to_list", replyToList)
+        put("attachment_count", attachmentCount)
+        put("internal_date", internalDate)
+        put("message_id", messageIdHeader)
+        put("preview_type", previewType.databaseValue)
+        put("preview", preview)
+        put("mime_type", mimeType)
+        put("normalized_subject_hash", normalizedSubjectHash)
+        put("empty", if (empty) 1 else 0)
+        put("read", if (read) 1 else 0)
+        put("flagged", if (flagged) 1 else 0)
+        put("answered", if (answered) 1 else 0)
+        put("forwarded", if (forwarded) 1 else 0)
+        put("message_part_id", messagePartId)
+        put("encryption_type", encryptionType)
+        put("new_message", if (newMessage) 1 else 0)
+    }
+
+    return insert("messages", null, values)
+}
+
+fun SQLiteDatabase.readMessages(): List<MessageEntry> {
+    val cursor = rawQuery("SELECT * FROM messages", null)
+    return cursor.use {
+        cursor.map {
+            MessageEntry(
+                id = cursor.getLongOrNull("id"),
+                deleted = cursor.getIntOrNull("deleted"),
+                folderId = cursor.getLongOrNull("folder_id"),
+                uid = cursor.getStringOrNull("uid"),
+                subject = cursor.getStringOrNull("subject"),
+                date = cursor.getLongOrNull("date"),
+                flags = cursor.getStringOrNull("flags"),
+                senderList = cursor.getStringOrNull("sender_list"),
+                toList = cursor.getStringOrNull("to_list"),
+                ccList = cursor.getStringOrNull("cc_list"),
+                bccList = cursor.getStringOrNull("bcc_list"),
+                replyToList = cursor.getStringOrNull("reply_to_list"),
+                attachmentCount = cursor.getIntOrNull("attachment_count"),
+                internalDate = cursor.getLongOrNull("internal_date"),
+                messageId = cursor.getStringOrNull("message_id"),
+                previewType = cursor.getStringOrNull("preview_type"),
+                preview = cursor.getStringOrNull("preview"),
+                mimeType = cursor.getStringOrNull("mime_type"),
+                normalizedSubjectHash = cursor.getLongOrNull("normalized_subject_hash"),
+                empty = cursor.getIntOrNull("empty"),
+                read = cursor.getIntOrNull("read"),
+                flagged = cursor.getIntOrNull("flagged"),
+                answered = cursor.getIntOrNull("answered"),
+                forwarded = cursor.getIntOrNull("forwarded"),
+                messagePartId = cursor.getLongOrNull("message_part_id"),
+                encryptionType = cursor.getStringOrNull("encryption_type"),
+                newMessage = cursor.getIntOrNull("new_message")
+            )
+        }
+    }
+}
+
+data class MessageEntry(
+    val id: Long?,
+    val deleted: Int?,
+    val folderId: Long?,
+    val uid: String?,
+    val subject: String?,
+    val date: Long?,
+    val flags: String?,
+    val senderList: String?,
+    val toList: String?,
+    val ccList: String?,
+    val bccList: String?,
+    val replyToList: String?,
+    val attachmentCount: Int?,
+    val internalDate: Long?,
+    val messageId: String?,
+    val previewType: String?,
+    val preview: String?,
+    val mimeType: String?,
+    val normalizedSubjectHash: Long?,
+    val empty: Int?,
+    val read: Int?,
+    val flagged: Int?,
+    val answered: Int?,
+    val forwarded: Int?,
+    val messagePartId: Long?,
+    val encryptionType: String?,
+    val newMessage: Int?
+)
+
+fun SQLiteDatabase.createMessagePart(
+    type: Int = 0,
+    root: Int? = null,
+    parent: Int = -1,
+    seq: Int = 0,
+    mimeType: String = "text/plain",
+    decodedBodySize: Int = 0,
+    displayName: String? = null,
+    header: String? = null,
+    encoding: String = "7bit",
+    charset: String? = null,
+    dataLocation: Int = 0,
+    data: ByteArray? = null,
+    preamble: String? = null,
+    epilogue: String? = null,
+    boundary: String? = null,
+    contentId: String? = null,
+    serverExtra: String? = null,
+    directory: File? = null
+): Long {
+    val values = ContentValues().apply {
+        put("type", type)
+        put("root", root)
+        put("parent", parent)
+        put("seq", seq)
+        put("mime_type", mimeType)
+        put("decoded_body_size", decodedBodySize)
+        put("display_name", displayName)
+        put("header", header?.toByteArray())
+        put("encoding", encoding)
+        put("charset", charset)
+        put("data_location", dataLocation)
+        put("data", data)
+        put("preamble", preamble)
+        put("epilogue", epilogue)
+        put("boundary", boundary)
+        put("content_id", contentId)
+        put("server_extra", serverExtra)
+    }
+
+    return insert("message_parts", null, values).also { messagePartId ->
+        if (dataLocation == DATA_LOCATION_ON_DISK) {
+            requireNotNull(directory) { "Argument 'directory' can't be null when 'dataLocation = 2'" }
+            File(directory, messagePartId.toString()).createNewFile()
+        }
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/MessagePartDatabaseHelpers.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/MessagePartDatabaseHelpers.kt
new file mode 100644
index 0000000..19e915e
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/MessagePartDatabaseHelpers.kt
@@ -0,0 +1,182 @@
+package com.fsck.k9.storage.messages
+
+import android.content.ContentValues
+import android.database.Cursor
+import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.android.common.database.getIntOrNull
+import app.k9mail.core.android.common.database.getLongOrNull
+import app.k9mail.core.android.common.database.getStringOrNull
+import app.k9mail.core.android.common.database.map
+
+fun SQLiteDatabase.createMessagePart(
+    type: Int = MessagePartType.UNKNOWN,
+    root: Long? = null,
+    parent: Long = -1,
+    seq: Int = 0,
+    mimeType: String? = null,
+    decodedBodySize: Int? = null,
+    displayName: String? = null,
+    header: String? = null,
+    encoding: String? = null,
+    charset: String? = null,
+    dataLocation: Int = DataLocation.MISSING,
+    data: ByteArray? = null,
+    preamble: String? = null,
+    epilogue: String? = null,
+    boundary: String? = null,
+    contentId: String? = null,
+    serverExtra: String? = null
+): Long {
+    val values = ContentValues().apply {
+        put("type", type)
+        put("root", root)
+        put("parent", parent)
+        put("seq", seq)
+        put("mime_type", mimeType)
+        put("decoded_body_size", decodedBodySize)
+        put("display_name", displayName)
+        put("header", header?.toByteArray())
+        put("encoding", encoding)
+        put("charset", charset)
+        put("data_location", dataLocation)
+        put("data", data)
+        put("preamble", preamble)
+        put("epilogue", epilogue)
+        put("boundary", boundary)
+        put("content_id", contentId)
+        put("server_extra", serverExtra)
+    }
+
+    return insert("message_parts", null, values)
+}
+
+fun SQLiteDatabase.readMessageParts(): List<MessagePartEntry> {
+    return rawQuery("SELECT * FROM message_parts", null).use { cursor ->
+        cursor.map {
+            MessagePartEntry(
+                id = cursor.getLongOrNull("id"),
+                type = cursor.getIntOrNull("type"),
+                root = cursor.getLongOrNull("root"),
+                parent = cursor.getLongOrNull("parent"),
+                seq = cursor.getIntOrNull("seq"),
+                mimeType = cursor.getStringOrNull("mime_type"),
+                decodedBodySize = cursor.getIntOrNull("decoded_body_size"),
+                displayName = cursor.getStringOrNull("display_name"),
+                header = cursor.getBlobOrNull("header"),
+                encoding = cursor.getStringOrNull("encoding"),
+                charset = cursor.getStringOrNull("charset"),
+                dataLocation = cursor.getIntOrNull("data_location"),
+                data = cursor.getBlobOrNull("data"),
+                preamble = cursor.getStringOrNull("preamble"),
+                epilogue = cursor.getStringOrNull("epilogue"),
+                boundary = cursor.getStringOrNull("boundary"),
+                contentId = cursor.getStringOrNull("content_id"),
+                serverExtra = cursor.getStringOrNull("server_extra")
+            )
+        }
+    }
+}
+
+data class MessagePartEntry(
+    val id: Long?,
+    val type: Int?,
+    val root: Long?,
+    val parent: Long?,
+    val seq: Int?,
+    val mimeType: String?,
+    val decodedBodySize: Int?,
+    val displayName: String?,
+    val header: ByteArray?,
+    val encoding: String?,
+    val charset: String?,
+    val dataLocation: Int?,
+    val data: ByteArray?,
+    val preamble: String?,
+    val epilogue: String?,
+    val boundary: String?,
+    val contentId: String?,
+    val serverExtra: String?
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as MessagePartEntry
+
+        if (id != other.id) return false
+        if (type != other.type) return false
+        if (root != other.root) return false
+        if (parent != other.parent) return false
+        if (seq != other.seq) return false
+        if (mimeType != other.mimeType) return false
+        if (decodedBodySize != other.decodedBodySize) return false
+        if (displayName != other.displayName) return false
+        if (header != null) {
+            if (other.header == null) return false
+            if (!header.contentEquals(other.header)) return false
+        } else if (other.header != null) return false
+        if (encoding != other.encoding) return false
+        if (charset != other.charset) return false
+        if (dataLocation != other.dataLocation) return false
+        if (data != null) {
+            if (other.data == null) return false
+            if (!data.contentEquals(other.data)) return false
+        } else if (other.data != null) return false
+        if (preamble != other.preamble) return false
+        if (epilogue != other.epilogue) return false
+        if (boundary != other.boundary) return false
+        if (contentId != other.contentId) return false
+        if (serverExtra != other.serverExtra) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = id?.hashCode() ?: 0
+        result = 31 * result + (type ?: 0)
+        result = 31 * result + (root?.hashCode() ?: 0)
+        result = 31 * result + (parent?.hashCode() ?: 0)
+        result = 31 * result + (seq ?: 0)
+        result = 31 * result + (mimeType?.hashCode() ?: 0)
+        result = 31 * result + (decodedBodySize ?: 0)
+        result = 31 * result + (displayName?.hashCode() ?: 0)
+        result = 31 * result + (header?.contentHashCode() ?: 0)
+        result = 31 * result + (encoding?.hashCode() ?: 0)
+        result = 31 * result + (charset?.hashCode() ?: 0)
+        result = 31 * result + (dataLocation ?: 0)
+        result = 31 * result + (data?.contentHashCode() ?: 0)
+        result = 31 * result + (preamble?.hashCode() ?: 0)
+        result = 31 * result + (epilogue?.hashCode() ?: 0)
+        result = 31 * result + (boundary?.hashCode() ?: 0)
+        result = 31 * result + (contentId?.hashCode() ?: 0)
+        result = 31 * result + (serverExtra?.hashCode() ?: 0)
+        return result
+    }
+
+    override fun toString(): String {
+        return "MessagePartEntry(" +
+            "id=$id, " +
+            "type=$type, " +
+            "root=$root, " +
+            "parent=$parent, " +
+            "seq=$seq, " +
+            "mimeType=$mimeType, " +
+            "decodedBodySize=$decodedBodySize, " +
+            "displayName=$displayName, " +
+            "header=${header?.decodeToString()}, " +
+            "encoding=$encoding, " +
+            "charset=$charset, " +
+            "dataLocation=$dataLocation, " +
+            "data=${data?.decodeToString()}, " +
+            "preamble=$preamble, " +
+            "epilogue=$epilogue, " +
+            "boundary=$boundary, " +
+            "contentId=$contentId, " +
+            "serverExtra=$serverExtra)"
+    }
+}
+
+private fun Cursor.getBlobOrNull(columnName: String): ByteArray? {
+    val columnIndex = getColumnIndex(columnName)
+    return if (isNull(columnIndex)) null else getBlob(columnIndex)
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
new file mode 100644
index 0000000..00dc9e4
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
@@ -0,0 +1,216 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.startsWith
+import com.fsck.k9.K9
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+import org.junit.Assert.fail as junitFail
+
+private const val SOURCE_FOLDER_ID = 3L
+private const val DESTINATION_FOLDER_ID = 23L
+private const val MESSAGE_ID_HEADER = "<00000000-0000-4000-0000-000000000000@domain.example>"
+
+class MoveMessageOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val moveMessageOperations = MoveMessageOperations(lockableDatabase, ThreadMessageOperations())
+
+    @Test
+    fun `move message not part of a thread`() {
+        val originalMessageId = sqliteDatabase.createMessage(
+            folderId = SOURCE_FOLDER_ID,
+            uid = "uid1",
+            subject = "Move me",
+            messageIdHeader = MESSAGE_ID_HEADER
+        )
+        sqliteDatabase.createThread(messageId = originalMessageId)
+        val originalMessage = sqliteDatabase.readMessages().first()
+
+        val destinationMessageId = moveMessageOperations.moveMessage(
+            messageId = originalMessageId,
+            destinationFolderId = DESTINATION_FOLDER_ID
+        )
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(2)
+
+        val sourceMessage = messages.first { it.id == originalMessageId }
+        assertThat(sourceMessage.folderId).isEqualTo(SOURCE_FOLDER_ID)
+        assertThat(sourceMessage.uid).isEqualTo("uid1")
+        assertThat(sourceMessage.messageId).isEqualTo(MESSAGE_ID_HEADER)
+        assertPlaceholderEntry(sourceMessage)
+
+        val destinationMessage = messages.first { it.id == destinationMessageId }
+        assertThat(destinationMessage.uid).isNotNull().startsWith(K9.LOCAL_UID_PREFIX)
+        assertThat(destinationMessage).isEqualTo(
+            originalMessage.copy(
+                id = destinationMessageId,
+                folderId = DESTINATION_FOLDER_ID,
+                uid = destinationMessage.uid,
+                deleted = 0,
+                empty = 0
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(2)
+
+        val originalMessageThread = threads.first { it.messageId == originalMessageId }
+        assertThat(originalMessageThread.id).isEqualTo(originalMessageThread.root)
+        assertThat(originalMessageThread.parent).isNull()
+
+        val destinationMessageThread = threads.first { it.messageId == destinationMessageId }
+        assertThat(destinationMessageThread.id).isEqualTo(destinationMessageThread.root)
+        assertThat(destinationMessageThread.parent).isNull()
+    }
+
+    @Test
+    fun `move message when destination has empty message entry`() {
+        val originalMessageId = sqliteDatabase.createMessage(
+            folderId = SOURCE_FOLDER_ID,
+            uid = "uid1",
+            subject = "Move me",
+            messageIdHeader = MESSAGE_ID_HEADER,
+            read = false
+        )
+        sqliteDatabase.createThread(messageId = originalMessageId)
+        val originalMessage = sqliteDatabase.readMessages().first()
+        val placeholderMessageId = sqliteDatabase.createMessage(
+            empty = true,
+            folderId = DESTINATION_FOLDER_ID,
+            messageIdHeader = MESSAGE_ID_HEADER,
+            uid = ""
+        )
+        val placeholderThreadId = sqliteDatabase.createThread(messageId = placeholderMessageId)
+        val childMessageId = sqliteDatabase.createMessage(
+            folderId = DESTINATION_FOLDER_ID,
+            messageIdHeader = "<msg02@domain.example>",
+            uid = "uid2"
+        )
+        sqliteDatabase.createThread(
+            messageId = childMessageId,
+            root = placeholderThreadId,
+            parent = placeholderThreadId
+        )
+
+        val destinationMessageId = moveMessageOperations.moveMessage(
+            messageId = originalMessageId,
+            destinationFolderId = DESTINATION_FOLDER_ID
+        )
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(3)
+
+        val sourceMessage = messages.first { it.id == originalMessageId }
+        assertThat(sourceMessage.folderId).isEqualTo(SOURCE_FOLDER_ID)
+        assertThat(sourceMessage.uid).isEqualTo("uid1")
+        assertThat(sourceMessage.messageId).isEqualTo(MESSAGE_ID_HEADER)
+        assertPlaceholderEntry(sourceMessage)
+
+        val destinationMessage = messages.first { it.id == destinationMessageId }
+        assertThat(destinationMessage.uid).isNotNull().startsWith(K9.LOCAL_UID_PREFIX)
+        assertThat(destinationMessage).isEqualTo(
+            originalMessage.copy(
+                id = destinationMessageId,
+                folderId = DESTINATION_FOLDER_ID,
+                uid = destinationMessage.uid,
+                deleted = 0,
+                empty = 0
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(3)
+
+        val originalMessageThread = threads.first { it.messageId == originalMessageId }
+        assertThat(originalMessageThread.id).isEqualTo(originalMessageThread.root)
+        assertThat(originalMessageThread.parent).isNull()
+
+        val destinationMessageThread = threads.first { it.messageId == destinationMessageId }
+        assertThat(destinationMessageThread.id).isEqualTo(destinationMessageThread.root)
+        assertThat(destinationMessageThread.parent).isNull()
+
+        val childMessageThread = threads.first { it.messageId == childMessageId }
+        assertThat(childMessageThread.root).isEqualTo(destinationMessageThread.id)
+        assertThat(childMessageThread.parent).isEqualTo(destinationMessageThread.id)
+    }
+
+    @Test
+    fun `move message not containing a message-id header`() {
+        val originalMessageId = sqliteDatabase.createMessage(
+            folderId = SOURCE_FOLDER_ID,
+            uid = "uid1",
+            subject = "Move me",
+            messageIdHeader = null
+        )
+        sqliteDatabase.createThread(messageId = originalMessageId)
+        val originalMessage = sqliteDatabase.readMessages().first()
+
+        val destinationMessageId = moveMessageOperations.moveMessage(
+            messageId = originalMessageId,
+            destinationFolderId = DESTINATION_FOLDER_ID
+        )
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(2)
+
+        val sourceMessage = messages.first { it.id == originalMessageId }
+        assertThat(sourceMessage.folderId).isEqualTo(SOURCE_FOLDER_ID)
+        assertThat(sourceMessage.uid).isEqualTo("uid1")
+        assertPlaceholderEntry(sourceMessage)
+
+        val destinationMessage = messages.first { it.id == destinationMessageId }
+        assertThat(destinationMessage.uid).isNotNull().startsWith(K9.LOCAL_UID_PREFIX)
+        assertThat(destinationMessage).isEqualTo(
+            originalMessage.copy(
+                id = destinationMessageId,
+                folderId = DESTINATION_FOLDER_ID,
+                uid = destinationMessage.uid,
+                deleted = 0,
+                empty = 0
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(2)
+
+        val originalMessageThread = threads.first { it.messageId == originalMessageId }
+        assertThat(originalMessageThread.id).isEqualTo(originalMessageThread.root)
+        assertThat(originalMessageThread.parent).isNull()
+
+        val destinationMessageThread = threads.first { it.messageId == destinationMessageId }
+        assertThat(destinationMessageThread.id).isEqualTo(destinationMessageThread.root)
+        assertThat(destinationMessageThread.parent).isNull()
+    }
+
+    private fun assertPlaceholderEntry(message: MessageEntry) {
+        assertThat(message.deleted).isEqualTo(1)
+        assertThat(message.empty).isEqualTo(0)
+        assertThat(message.read).isEqualTo(1)
+        assertThat(message.date).isNull()
+        assertThat(message.flags).isNull()
+        assertThat(message.senderList).isNull()
+        assertThat(message.toList).isNull()
+        assertThat(message.ccList).isNull()
+        assertThat(message.bccList).isNull()
+        assertThat(message.replyToList).isNull()
+        assertThat(message.attachmentCount).isNull()
+        assertThat(message.internalDate).isNull()
+        assertThat(message.previewType).isEqualTo("none")
+        assertThat(message.preview).isNull()
+        assertThat(message.mimeType).isNull()
+        assertThat(message.normalizedSubjectHash).isNull()
+        assertThat(message.flagged).isNull()
+        assertThat(message.answered).isNull()
+        assertThat(message.forwarded).isNull()
+        assertThat(message.messagePartId).isNull()
+        assertThat(message.encryptionType).isNull()
+    }
+
+    private fun fail(message: String): Nothing = junitFail(message) as Nothing
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
new file mode 100644
index 0000000..d4eb74f
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
@@ -0,0 +1,522 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFailure
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import com.fsck.k9.Account.FolderMode
+import com.fsck.k9.mail.FolderClass
+import com.fsck.k9.mail.FolderType
+import com.fsck.k9.mailstore.FolderNotFoundException
+import com.fsck.k9.mailstore.MoreMessages
+import com.fsck.k9.mailstore.toDatabaseFolderType
+import com.fsck.k9.search.LocalSearch
+import com.fsck.k9.search.SearchSpecification
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class RetrieveFolderOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val retrieveFolderOperations = RetrieveFolderOperations(lockableDatabase)
+
+    @Test
+    fun `get folder`() {
+        val folderId = sqliteDatabase.createFolder(
+            name = "Folder Name",
+            type = "inbox",
+            serverId = "uid",
+            isLocalOnly = false,
+            integrate = true,
+            inTopGroup = true,
+            displayClass = "FIRST_CLASS",
+            syncClass = "FIRST_CLASS",
+            notifyClass = "NO_CLASS",
+            pushClass = "NO_CLASS"
+        )
+
+        val result = retrieveFolderOperations.getFolder(folderId) { folder ->
+            assertThat(folder.id).isEqualTo(folderId)
+            assertThat(folder.name).isEqualTo("Folder Name")
+            assertThat(folder.type).isEqualTo(FolderType.INBOX)
+            assertThat(folder.serverId).isEqualTo("uid")
+            assertThat(folder.isLocalOnly).isEqualTo(false)
+            assertThat(folder.isIntegrate).isEqualTo(true)
+            assertThat(folder.isInTopGroup).isEqualTo(true)
+            assertThat(folder.displayClass).isEqualTo(FolderClass.FIRST_CLASS)
+            assertThat(folder.syncClass).isEqualTo(FolderClass.FIRST_CLASS)
+            assertThat(folder.notifyClass).isEqualTo(FolderClass.NO_CLASS)
+            assertThat(folder.pushClass).isEqualTo(FolderClass.NO_CLASS)
+            true
+        }
+
+        assertThat(result).isNotNull().isTrue()
+    }
+
+    @Test
+    fun `get local folder`() {
+        val name = "Local outbox"
+        val folderId = sqliteDatabase.createFolder(
+            name = name,
+            type = FolderType.OUTBOX.toDatabaseFolderType(),
+            serverId = null,
+            isLocalOnly = true,
+            integrate = true,
+            inTopGroup = true,
+            displayClass = FolderClass.FIRST_CLASS.name,
+            syncClass = null,
+            notifyClass = null,
+            pushClass = null
+        )
+
+        val result = retrieveFolderOperations.getFolder(folderId) { folder ->
+            assertThat(folder.id).isEqualTo(folderId)
+            assertThat(folder.name).isEqualTo(name)
+            assertThat(folder.type).isEqualTo(FolderType.OUTBOX)
+            assertThat(folder.serverId).isNull()
+            assertThat(folder.isLocalOnly).isEqualTo(true)
+            assertThat(folder.isIntegrate).isEqualTo(true)
+            assertThat(folder.isInTopGroup).isEqualTo(true)
+            assertThat(folder.displayClass).isEqualTo(FolderClass.FIRST_CLASS)
+            assertThat(folder.syncClass).isEqualTo(FolderClass.INHERITED)
+            assertThat(folder.notifyClass).isEqualTo(FolderClass.INHERITED)
+            assertThat(folder.pushClass).isEqualTo(FolderClass.SECOND_CLASS)
+            true
+        }
+
+        assertThat(result).isNotNull().isTrue()
+    }
+
+    @Test
+    fun `get non-existent folder should return null`() {
+        val result = retrieveFolderOperations.getFolder(1) { "failed" }
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `get folder by server ID`() {
+        val folderId = sqliteDatabase.createFolder(
+            name = "Folder Name",
+            type = "inbox",
+            serverId = "folder1",
+            isLocalOnly = false,
+            integrate = true,
+            inTopGroup = true,
+            displayClass = "FIRST_CLASS",
+            syncClass = "FIRST_CLASS",
+            notifyClass = "NO_CLASS",
+            pushClass = "NO_CLASS"
+        )
+
+        val result = retrieveFolderOperations.getFolder("folder1") { folder ->
+            assertThat(folder.id).isEqualTo(folderId)
+            assertThat(folder.name).isEqualTo("Folder Name")
+            assertThat(folder.type).isEqualTo(FolderType.INBOX)
+            assertThat(folder.serverId).isEqualTo("folder1")
+            assertThat(folder.isLocalOnly).isEqualTo(false)
+            assertThat(folder.isIntegrate).isEqualTo(true)
+            assertThat(folder.isInTopGroup).isEqualTo(true)
+            assertThat(folder.displayClass).isEqualTo(FolderClass.FIRST_CLASS)
+            assertThat(folder.syncClass).isEqualTo(FolderClass.FIRST_CLASS)
+            assertThat(folder.notifyClass).isEqualTo(FolderClass.NO_CLASS)
+            assertThat(folder.pushClass).isEqualTo(FolderClass.NO_CLASS)
+            true
+        }
+
+        assertThat(result).isNotNull().isTrue()
+    }
+
+    @Test
+    fun `get non-existent folder by server ID should return null`() {
+        val result = retrieveFolderOperations.getFolder("folder_id") { "failed" }
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `get folders should return all fields`() {
+        val folderId = sqliteDatabase.createFolder(
+            name = "Folder Name",
+            type = "inbox",
+            serverId = "uid",
+            isLocalOnly = false,
+            integrate = true,
+            inTopGroup = true,
+            displayClass = "FIRST_CLASS",
+            syncClass = "FIRST_CLASS",
+            notifyClass = "NO_CLASS",
+            pushClass = "NO_CLASS"
+        )
+
+        val result = retrieveFolderOperations.getFolders { folder ->
+            assertThat(folder.id).isEqualTo(folderId)
+            assertThat(folder.name).isEqualTo("Folder Name")
+            assertThat(folder.type).isEqualTo(FolderType.INBOX)
+            assertThat(folder.serverId).isEqualTo("uid")
+            assertThat(folder.isLocalOnly).isEqualTo(false)
+            assertThat(folder.isIntegrate).isEqualTo(true)
+            assertThat(folder.isInTopGroup).isEqualTo(true)
+            assertThat(folder.displayClass).isEqualTo(FolderClass.FIRST_CLASS)
+            assertThat(folder.syncClass).isEqualTo(FolderClass.FIRST_CLASS)
+            assertThat(folder.notifyClass).isEqualTo(FolderClass.NO_CLASS)
+            assertThat(folder.pushClass).isEqualTo(FolderClass.NO_CLASS)
+            true
+        }
+
+        assertThat(result).isEqualTo(listOf(true))
+    }
+
+    @Test
+    fun `get folders with excludeLocalOnly should only return remote folders`() {
+        val (folderId1, _, folderId3) = listOf(
+            sqliteDatabase.createFolder(name = "Folder 1", isLocalOnly = false),
+            sqliteDatabase.createFolder(name = "Folder 2", isLocalOnly = true),
+            sqliteDatabase.createFolder(name = "Folder 3", isLocalOnly = false)
+        )
+
+        val result = retrieveFolderOperations.getFolders(excludeLocalOnly = true) { folder ->
+            folder.id to folder.name
+        }
+
+        assertThat(result).isEqualTo(
+            listOf(
+                folderId1 to "Folder 1",
+                folderId3 to "Folder 3"
+            )
+        )
+    }
+
+    @Test
+    fun `get folders with empty store should return empty list`() {
+        val result = retrieveFolderOperations.getFolders { "failed" }
+
+        assertThat(result).isEmpty()
+    }
+
+    @Test
+    fun `get first class display folders`() {
+        val (folderId1, folderId2, _) = listOf(
+            sqliteDatabase.createFolder(name = "Folder 1", displayClass = "FIRST_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 2", displayClass = "SECOND_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 3", displayClass = "NO_CLASS")
+        )
+
+        val result = retrieveFolderOperations.getDisplayFolders(
+            displayMode = FolderMode.FIRST_CLASS,
+            outboxFolderId = folderId2
+        ) { folder ->
+            folder.id to folder.name
+        }
+
+        assertThat(result).isEqualTo(listOf(folderId1 to "Folder 1"))
+    }
+
+    @Test
+    fun `get everything but second class display folders`() {
+        val (folderId1, _, folderId3) = listOf(
+            sqliteDatabase.createFolder(name = "Folder 1", displayClass = "FIRST_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 2", displayClass = "SECOND_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 3", displayClass = "NO_CLASS")
+        )
+
+        val result = retrieveFolderOperations.getDisplayFolders(
+            displayMode = FolderMode.NOT_SECOND_CLASS,
+            outboxFolderId = folderId1
+        ) { folder ->
+            folder.id to folder.name
+        }
+
+        assertThat(result).isEqualTo(
+            listOf(
+                folderId1 to "Folder 1",
+                folderId3 to "Folder 3"
+            )
+        )
+    }
+
+    @Test
+    fun `get first and second class display folders`() {
+        val (folderId1, folderId2, _) = listOf(
+            sqliteDatabase.createFolder(name = "Folder 1", displayClass = "FIRST_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 2", displayClass = "SECOND_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 3", displayClass = "NO_CLASS")
+        )
+
+        val result = retrieveFolderOperations.getDisplayFolders(
+            displayMode = FolderMode.FIRST_AND_SECOND_CLASS,
+            outboxFolderId = folderId1
+        ) { folder ->
+            folder.id to folder.name
+        }
+
+        assertThat(result).isEqualTo(
+            listOf(
+                folderId1 to "Folder 1",
+                folderId2 to "Folder 2"
+            )
+        )
+    }
+
+    @Test
+    fun `get display folders with message count`() {
+        val (folderId1, folderId2, folderId3, folderId4) = listOf(
+            sqliteDatabase.createFolder(name = "Folder 1", displayClass = "FIRST_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 2", displayClass = "SECOND_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 3", displayClass = "FIRST_CLASS"),
+            sqliteDatabase.createFolder(name = "Folder 4", displayClass = "NO_CLASS")
+        )
+        sqliteDatabase.createMessage(uid = "msg1", folderId = folderId1, read = true)
+        sqliteDatabase.createMessage(uid = "msg2", folderId = folderId2, read = true)
+        sqliteDatabase.createMessage(uid = "msg3", folderId = folderId3, read = true)
+        sqliteDatabase.createMessage(uid = "msg4", folderId = folderId3, read = false)
+        sqliteDatabase.createMessage(uid = "msg5", folderId = folderId3, read = false)
+
+        val result = retrieveFolderOperations.getDisplayFolders(
+            displayMode = FolderMode.ALL,
+            outboxFolderId = folderId2
+        ) { folder ->
+            Triple(folder.id, folder.name, folder.unreadMessageCount)
+        }
+
+        assertThat(result).hasSize(4)
+        assertThat(result.toSet()).isEqualTo(
+            setOf(
+                Triple(folderId1, "Folder 1", 0),
+                Triple(folderId2, "Folder 2", 1),
+                Triple(folderId3, "Folder 3", 2),
+                Triple(folderId4, "Folder 4", 0)
+            )
+        )
+    }
+
+    @Test
+    fun `get folder id`() {
+        val (_, folderId2) = listOf(
+            sqliteDatabase.createFolder(serverId = "folder1"),
+            sqliteDatabase.createFolder(serverId = "folder2")
+        )
+
+        val result = retrieveFolderOperations.getFolderId(folderServerId = "folder2")
+
+        assertThat(result).isEqualTo(folderId2)
+    }
+
+    @Test
+    fun `get folder id should return null if no folder was found`() {
+        val result = retrieveFolderOperations.getFolderId(folderServerId = "folderId")
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `get folder server id`() {
+        val (_, folderId2) = listOf(
+            sqliteDatabase.createFolder(serverId = "folder1"),
+            sqliteDatabase.createFolder(serverId = "folder2")
+        )
+
+        val result = retrieveFolderOperations.getFolderServerId(folderId2)
+
+        assertThat(result).isEqualTo("folder2")
+    }
+
+    @Test
+    fun `get folder server id should return null if no folder was found`() {
+        val result = retrieveFolderOperations.getFolderServerId(folderId = 1)
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `get message count from empty folder`() {
+        val folderId = sqliteDatabase.createFolder()
+
+        val result = retrieveFolderOperations.getMessageCount(folderId)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get message count from non-existent folder`() {
+        val result = retrieveFolderOperations.getMessageCount(23)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get message count from non-empty folder`() {
+        val folderId = sqliteDatabase.createFolder()
+        sqliteDatabase.createMessage(folderId = folderId)
+        sqliteDatabase.createMessage(folderId = folderId)
+
+        val result = retrieveFolderOperations.getMessageCount(folderId)
+
+        assertThat(result).isEqualTo(2)
+    }
+
+    @Test
+    fun `get unread message count from empty folder`() {
+        val folderId = sqliteDatabase.createFolder()
+
+        val result = retrieveFolderOperations.getUnreadMessageCount(folderId)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get unread message count from non-existent folder`() {
+        val result = retrieveFolderOperations.getUnreadMessageCount(23)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get unread message count from non-empty folder`() {
+        val folderId = sqliteDatabase.createFolder()
+        sqliteDatabase.createMessage(folderId = folderId, read = false)
+        sqliteDatabase.createMessage(folderId = folderId, read = false)
+        sqliteDatabase.createMessage(folderId = folderId, read = true)
+
+        val result = retrieveFolderOperations.getUnreadMessageCount(folderId)
+
+        assertThat(result).isEqualTo(2)
+    }
+
+    @Test
+    fun `get unread message count with condition from empty folder`() {
+        sqliteDatabase.createFolder(integrate = true)
+
+        val result = retrieveFolderOperations.getUnreadMessageCount(unifiedInboxConditions)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get unread message count with condition from non-existent folder`() {
+        val result = retrieveFolderOperations.getUnreadMessageCount(unifiedInboxConditions)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get unread message count with condition from non-empty folder`() {
+        val folderId1 = sqliteDatabase.createFolder(integrate = true)
+        sqliteDatabase.createMessage(folderId = folderId1, read = false)
+        sqliteDatabase.createMessage(folderId = folderId1, read = false)
+        sqliteDatabase.createMessage(folderId = folderId1, read = true)
+        val folderId2 = sqliteDatabase.createFolder(integrate = true)
+        sqliteDatabase.createMessage(folderId = folderId2, read = false)
+        sqliteDatabase.createMessage(folderId = folderId2, read = true)
+        val folderId3 = sqliteDatabase.createFolder(integrate = false)
+        sqliteDatabase.createMessage(folderId = folderId3, read = false)
+
+        val result = retrieveFolderOperations.getUnreadMessageCount(unifiedInboxConditions)
+
+        assertThat(result).isEqualTo(3)
+    }
+
+    @Test
+    fun `get unread message count without condition`() {
+        val folderId1 = sqliteDatabase.createFolder(integrate = true)
+        sqliteDatabase.createMessage(folderId = folderId1, read = false)
+        val folderId2 = sqliteDatabase.createFolder(integrate = false)
+        sqliteDatabase.createMessage(folderId = folderId2, read = false)
+        sqliteDatabase.createMessage(folderId = folderId2, read = true)
+
+        val result = retrieveFolderOperations.getUnreadMessageCount(conditions = null)
+
+        assertThat(result).isEqualTo(2)
+    }
+
+    @Test
+    fun `get starred message count with condition from empty folder`() {
+        sqliteDatabase.createFolder(integrate = true)
+
+        val result = retrieveFolderOperations.getStarredMessageCount(unifiedInboxConditions)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get starred message count with condition from non-existent folder`() {
+        val result = retrieveFolderOperations.getStarredMessageCount(unifiedInboxConditions)
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `get starred message count with condition from non-empty folder`() {
+        val folderId1 = sqliteDatabase.createFolder(integrate = true)
+        sqliteDatabase.createMessage(folderId = folderId1, flagged = false)
+        sqliteDatabase.createMessage(folderId = folderId1, flagged = true)
+        val folderId2 = sqliteDatabase.createFolder(integrate = true)
+        sqliteDatabase.createMessage(folderId = folderId2, flagged = true)
+        sqliteDatabase.createMessage(folderId = folderId2, flagged = true)
+        sqliteDatabase.createMessage(folderId = folderId2, flagged = false)
+        val folderId3 = sqliteDatabase.createFolder(integrate = false)
+        sqliteDatabase.createMessage(folderId = folderId3, flagged = true)
+
+        val result = retrieveFolderOperations.getStarredMessageCount(unifiedInboxConditions)
+
+        assertThat(result).isEqualTo(3)
+    }
+
+    @Test
+    fun `get starred message count without condition`() {
+        val folderId1 = sqliteDatabase.createFolder(integrate = true)
+        sqliteDatabase.createMessage(folderId = folderId1, flagged = true)
+        val folderId2 = sqliteDatabase.createFolder(integrate = false)
+        sqliteDatabase.createMessage(folderId = folderId2, flagged = true)
+        sqliteDatabase.createMessage(folderId = folderId2, flagged = false)
+
+        val result = retrieveFolderOperations.getStarredMessageCount(conditions = null)
+
+        assertThat(result).isEqualTo(2)
+    }
+
+    @Test
+    fun `get 'more messages' value from non-existent folder`() {
+        assertThat {
+            retrieveFolderOperations.hasMoreMessages(23)
+        }.isFailure()
+            .isInstanceOf(FolderNotFoundException::class)
+            .transform { it.folderId }.isEqualTo(23)
+    }
+
+    @Test
+    fun `get 'more messages' value from folder with value 'unknown'`() {
+        val folderId = sqliteDatabase.createFolder(moreMessages = "unknown")
+
+        val result = retrieveFolderOperations.hasMoreMessages(folderId)
+
+        assertThat(result).isEqualTo(MoreMessages.UNKNOWN)
+    }
+
+    @Test
+    fun `get 'more messages' value from folder with value 'false'`() {
+        val folderId = sqliteDatabase.createFolder(moreMessages = "false")
+
+        val result = retrieveFolderOperations.hasMoreMessages(folderId)
+
+        assertThat(result).isEqualTo(MoreMessages.FALSE)
+    }
+
+    @Test
+    fun `get 'more messages' value from folder with value 'true'`() {
+        val folderId = sqliteDatabase.createFolder(moreMessages = "true")
+
+        val result = retrieveFolderOperations.hasMoreMessages(folderId)
+
+        assertThat(result).isEqualTo(MoreMessages.TRUE)
+    }
+
+    private val unifiedInboxConditions = LocalSearch().apply {
+        and(SearchSpecification.SearchField.INTEGRATE, "1", SearchSpecification.Attribute.EQUALS)
+    }.conditions
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveMessageListOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveMessageListOperationsTest.kt
new file mode 100644
index 0000000..c009d68
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveMessageListOperationsTest.kt
@@ -0,0 +1,491 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import com.fsck.k9.mail.Address
+import com.fsck.k9.mailstore.DatabasePreviewType
+import com.fsck.k9.mailstore.MessageMapper
+import com.fsck.k9.message.extractors.PreviewResult.PreviewType
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class RetrieveMessageListOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val retrieveMessageListOperations = RetrieveMessageListOperations(lockableDatabase)
+
+    @Test
+    fun `getMessages() on empty folder`() {
+        val folderId = sqliteDatabase.createFolder()
+
+        val result = getMessagesFromFolder(folderId) { "unexpected" }
+
+        assertThat(result).isEmpty()
+    }
+
+    @Test
+    fun `getMessages() with only a deleted message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId = sqliteDatabase.createMessage(folderId, uid = "uid1", deleted = true)
+        sqliteDatabase.createThread(messageId)
+
+        val result = getMessagesFromFolder(folderId) { "unexpected" }
+
+        assertThat(result).isEmpty()
+    }
+
+    @Test
+    fun `getMessages() with single message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId = sqliteDatabase.createMessage(
+            folderId,
+            uid = "uid1",
+            subject = "subject",
+            date = 123L,
+            senderList = Address.pack(Address.parse("from@domain.example")),
+            toList = Address.pack(Address.parse("to@domain.example")),
+            ccList = Address.pack(Address.parse("cc1@domain.example, cc2@domain.example")),
+            attachmentCount = 1,
+            internalDate = 456L,
+            previewType = DatabasePreviewType.TEXT,
+            preview = "preview",
+            read = true,
+            flagged = true,
+            answered = true,
+            forwarded = true
+        )
+        val threadId = sqliteDatabase.createThread(messageId)
+
+        val result = getMessagesFromFolder(folderId) { message ->
+            assertThat(message.id).isEqualTo(messageId)
+            assertThat(message.messageServerId).isEqualTo("uid1")
+            assertThat(message.folderId).isEqualTo(folderId)
+            assertThat(message.fromAddresses).containsExactly(Address("from@domain.example"))
+            assertThat(message.toAddresses).containsExactly(Address("to@domain.example"))
+            assertThat(message.ccAddresses).containsExactly(Address("cc1@domain.example"), Address("cc2@domain.example"))
+            assertThat(message.messageDate).isEqualTo(123L)
+            assertThat(message.internalDate).isEqualTo(456L)
+            assertThat(message.subject).isEqualTo("subject")
+            assertThat(message.preview.previewType).isEqualTo(PreviewType.TEXT)
+            assertThat(message.preview.previewText).isEqualTo("preview")
+            assertThat(message.isRead).isTrue()
+            assertThat(message.isStarred).isTrue()
+            assertThat(message.isAnswered).isTrue()
+            assertThat(message.isForwarded).isTrue()
+            assertThat(message.hasAttachments).isTrue()
+            assertThat(message.threadRoot).isEqualTo(threadId)
+            assertThat(message.threadCount).isEqualTo(0)
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getMessages() with folder containing an empty message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, empty = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2")
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message -> message.id }
+
+        assertThat(result).containsExactly(messageId2)
+    }
+
+    @Test
+    fun `getMessages() with folder containing a deleted message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, deleted = true)
+        sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2")
+        sqliteDatabase.createThread(messageId2)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message -> message.id }
+
+        assertThat(result).containsExactly(messageId2)
+    }
+
+    @Test
+    fun `getMessages() selecting only unread messages`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", read = false)
+        sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", read = true)
+        sqliteDatabase.createThread(messageId2)
+        val messageId3 = sqliteDatabase.createMessage(folderId, uid = "uid3", read = false)
+        sqliteDatabase.createThread(messageId3)
+
+        val result = retrieveMessageListOperations.getThreadedMessages(
+            selection = "folder_id = ? AND read = 0",
+            selectionArgs = arrayOf(folderId.toString()),
+            sortOrder = "date DESC, id DESC"
+        ) { message ->
+            message.id
+        }
+
+        assertThat(result).containsExactly(messageId3, messageId1)
+    }
+
+    @Test
+    fun `getThreadedMessages() on empty folder`() {
+        val folderId = sqliteDatabase.createFolder()
+
+        val result = getThreadedMessagesFromFolder(folderId) { "unexpected" }
+
+        assertThat(result).isEmpty()
+    }
+
+    @Test
+    fun `getThreadedMessages() with only a deleted message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId = sqliteDatabase.createMessage(folderId, uid = "uid1", deleted = true)
+        sqliteDatabase.createThread(messageId)
+
+        val result = getThreadedMessagesFromFolder(folderId) { "unexpected" }
+
+        assertThat(result).isEmpty()
+    }
+
+    @Test
+    fun `getThreadedMessages() with single message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId = sqliteDatabase.createMessage(
+            folderId,
+            uid = "uid1",
+            subject = "subject",
+            date = 123L,
+            senderList = Address.pack(Address.parse("from@domain.example")),
+            toList = Address.pack(Address.parse("to@domain.example")),
+            ccList = Address.pack(Address.parse("cc1@domain.example, cc2@domain.example")),
+            attachmentCount = 1,
+            internalDate = 456L,
+            previewType = DatabasePreviewType.TEXT,
+            preview = "preview",
+            read = true,
+            flagged = true,
+            answered = true,
+            forwarded = true
+        )
+        val threadId = sqliteDatabase.createThread(messageId)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.id).isEqualTo(messageId)
+            assertThat(message.messageServerId).isEqualTo("uid1")
+            assertThat(message.folderId).isEqualTo(folderId)
+            assertThat(message.fromAddresses).containsExactly(Address("from@domain.example"))
+            assertThat(message.toAddresses).containsExactly(Address("to@domain.example"))
+            assertThat(message.ccAddresses).containsExactly(Address("cc1@domain.example"), Address("cc2@domain.example"))
+            assertThat(message.messageDate).isEqualTo(123L)
+            assertThat(message.internalDate).isEqualTo(456L)
+            assertThat(message.subject).isEqualTo("subject")
+            assertThat(message.preview.previewType).isEqualTo(PreviewType.TEXT)
+            assertThat(message.preview.previewText).isEqualTo("preview")
+            assertThat(message.isRead).isTrue()
+            assertThat(message.isStarred).isTrue()
+            assertThat(message.isAnswered).isTrue()
+            assertThat(message.isForwarded).isTrue()
+            assertThat(message.hasAttachments).isTrue()
+            assertThat(message.threadRoot).isEqualTo(threadId)
+            assertThat(message.threadCount).isEqualTo(1)
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() with thread containing an empty message`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, empty = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2")
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.id).isEqualTo(messageId2)
+            assertThat(message.messageServerId).isEqualTo("uid2")
+            assertThat(message.threadRoot).isEqualTo(threadId1)
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return latest message in thread`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId,
+            uid = "uid1",
+            date = 1000L,
+            internalDate = 1001L
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId,
+            uid = "uid2",
+            date = 2000L,
+            internalDate = 2001L
+        )
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.id).isEqualTo(messageId2)
+            assertThat(message.messageDate).isEqualTo(2000L)
+            assertThat(message.internalDate).isEqualTo(2001L)
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'unread' when at least one message in thread is marked as unread`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", read = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", read = false)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isRead).isFalse()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'read' when all messages in thread are marked as read`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", read = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", read = true)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isRead).isTrue()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'starred' when at least one message in thread is marked as starred`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", flagged = false)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", flagged = true)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isStarred).isTrue()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'not starred' when all messages in thread are not marked as starred`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", flagged = false)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", flagged = false)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isStarred).isFalse()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'not answered' when not all messages in thread are marked as answered`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", answered = false)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", answered = true)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isAnswered).isFalse()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'answered' when all messages in thread are marked as answered`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", answered = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", answered = true)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isAnswered).isTrue()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'not forwarded' when not all messages in thread are marked as forwarded`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", forwarded = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", forwarded = false)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isForwarded).isFalse()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'forwarded' when all messages in thread are marked as forwarded`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", forwarded = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", forwarded = true)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.isForwarded).isTrue()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'has attachment' when at least one message in thread contains an attachment`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", attachmentCount = 1)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", attachmentCount = 0)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.hasAttachments).isTrue()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should return 'has no attachment' when no message in thread contains an attachment`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", attachmentCount = 0)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2", attachmentCount = 0)
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.hasAttachments).isFalse()
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() with 3 messages in thread`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1")
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2")
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+        val messageId3 = sqliteDatabase.createMessage(folderId, uid = "uid3")
+        sqliteDatabase.createThread(messageId3, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.threadCount).isEqualTo(3)
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThreadedMessages() should not include empty messages in thread count`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1", empty = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2")
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+        val messageId3 = sqliteDatabase.createMessage(folderId, uid = "uid3")
+        sqliteDatabase.createThread(messageId3, root = threadId1)
+
+        val result = getThreadedMessagesFromFolder(folderId) { message ->
+            assertThat(message.threadCount).isEqualTo(2)
+            "OK"
+        }
+
+        assertThat(result).containsExactly("OK")
+    }
+
+    @Test
+    fun `getThread() with empty message as thread root`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, empty = true)
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2")
+        sqliteDatabase.createThread(messageId2, root = threadId1)
+        val messageId3 = sqliteDatabase.createMessage(folderId, uid = "uid3")
+        sqliteDatabase.createThread(messageId3, root = threadId1)
+
+        val result = retrieveMessageListOperations.getThread(threadId = threadId1, sortOrder = "date DESC") { it.id }
+
+        assertThat(result).containsExactly(messageId2, messageId3)
+    }
+
+    @Test
+    fun `getThread() should only return messages in thread`() {
+        val folderId = sqliteDatabase.createFolder()
+        val messageId1 = sqliteDatabase.createMessage(folderId, uid = "uid1")
+        sqliteDatabase.createThread(messageId1)
+        val messageId2 = sqliteDatabase.createMessage(folderId, uid = "uid2")
+        val threadId2 = sqliteDatabase.createThread(messageId2)
+        val messageId3 = sqliteDatabase.createMessage(folderId, uid = "uid3")
+        sqliteDatabase.createThread(messageId3, root = threadId2)
+
+        val result = retrieveMessageListOperations.getThread(threadId = threadId2, sortOrder = "date DESC") { it.id }
+
+        assertThat(result).containsExactly(messageId2, messageId3)
+    }
+
+    private fun <T> getMessagesFromFolder(folderId: Long, mapper: MessageMapper<T?>): List<T> {
+        return retrieveMessageListOperations.getMessages(
+            selection = "folder_id = ?",
+            selectionArgs = arrayOf(folderId.toString()),
+            sortOrder = "date DESC, id DESC",
+            mapper
+        )
+    }
+
+    private fun <T> getThreadedMessagesFromFolder(folderId: Long, mapper: MessageMapper<T?>): List<T> {
+        return retrieveMessageListOperations.getThreadedMessages(
+            selection = "folder_id = ?",
+            selectionArgs = arrayOf(folderId.toString()),
+            sortOrder = "date DESC, id DESC",
+            mapper
+        )
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveMessageOperationsTest.kt
new file mode 100644
index 0000000..e933fa6
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveMessageOperationsTest.kt
@@ -0,0 +1,222 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import com.fsck.k9.mail.Flag
+import com.fsck.k9.mail.Header
+import com.fsck.k9.mail.crlf
+import com.fsck.k9.storage.RobolectricTest
+import java.util.Date
+import org.junit.Test
+
+class RetrieveMessageOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val retrieveMessageOperations = RetrieveMessageOperations(lockableDatabase)
+
+    @Test
+    fun `get message server id of non-existent message`() {
+        val messageServerId = retrieveMessageOperations.getMessageServerId(42)
+
+        assertThat(messageServerId).isNull()
+    }
+
+    @Test
+    fun `get message server id`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1")
+        val messageId = sqliteDatabase.createMessage(folderId = 1, uid = "uid2")
+
+        val messageServerId = retrieveMessageOperations.getMessageServerId(messageId)
+
+        assertThat(messageServerId).isEqualTo("uid2")
+    }
+
+    @Test
+    fun `get message server ids`() {
+        val messageId1 = sqliteDatabase.createMessage(folderId = 1, uid = "uid1")
+        val messageId2 = sqliteDatabase.createMessage(folderId = 1, uid = "uid2")
+        val messageId3 = sqliteDatabase.createMessage(folderId = 1, uid = "uid3")
+        val messageId4 = sqliteDatabase.createMessage(folderId = 1, uid = "uid4")
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid5")
+        val messageIds = listOf(messageId1, messageId2, messageId3, messageId4)
+
+        val databaseIdToServerIdMapping = retrieveMessageOperations.getMessageServerIds(messageIds)
+
+        assertThat(databaseIdToServerIdMapping).isEqualTo(
+            mapOf(
+                messageId1 to "uid1",
+                messageId2 to "uid2",
+                messageId3 to "uid3",
+                messageId4 to "uid4"
+            )
+        )
+    }
+
+    @Test
+    fun `get all message server ids`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1")
+        sqliteDatabase.createMessage(folderId = 1, uid = "K9LOCAL:1")
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid3")
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid4")
+
+        val messageServerIds = retrieveMessageOperations.getMessageServerIds(folderId = 1)
+
+        assertThat(messageServerIds).isEqualTo(setOf("uid1", "uid3", "uid4"))
+    }
+
+    @Test
+    fun `check if message is present`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1")
+
+        val result = retrieveMessageOperations.isMessagePresent(folderId = 1, messageServerId = "uid1")
+
+        assertThat(result).isTrue()
+    }
+
+    @Test
+    fun `check if non-existent message is present`() {
+        val result = retrieveMessageOperations.isMessagePresent(folderId = 1, messageServerId = "uid1")
+
+        assertThat(result).isFalse()
+    }
+
+    @Test
+    fun `get message flags`() {
+        sqliteDatabase.createMessage(
+            folderId = 1,
+            uid = "uid1",
+            flags = "DRAFT,RECENT,X_DESTROYED,X_SEND_FAILED,X_SEND_IN_PROGRESS,X_DOWNLOADED_FULL," +
+                "X_DOWNLOADED_PARTIAL,X_REMOTE_COPY_STARTED,X_MIGRATED_FROM_V50,X_DRAFT_OPENPGP_INLINE," +
+                "X_SUBJECT_DECRYPTED",
+            deleted = true,
+            read = true,
+            flagged = true,
+            answered = true,
+            forwarded = true
+        )
+
+        val flags = retrieveMessageOperations.getMessageFlags(folderId = 1, messageServerId = "uid1")
+
+        assertThat(flags).isEqualTo(
+            setOf(
+                Flag.DELETED,
+                Flag.SEEN,
+                Flag.ANSWERED,
+                Flag.FLAGGED,
+                Flag.DRAFT,
+                Flag.RECENT,
+                Flag.FORWARDED,
+                Flag.X_DESTROYED,
+                Flag.X_SEND_FAILED,
+                Flag.X_SEND_IN_PROGRESS,
+                Flag.X_DOWNLOADED_FULL,
+                Flag.X_DOWNLOADED_PARTIAL,
+                Flag.X_REMOTE_COPY_STARTED,
+                Flag.X_MIGRATED_FROM_V50,
+                Flag.X_DRAFT_OPENPGP_INLINE,
+                Flag.X_SUBJECT_DECRYPTED
+            )
+        )
+    }
+
+    @Test
+    fun `get message flags without any flags set`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", flags = "")
+
+        val flags = retrieveMessageOperations.getMessageFlags(folderId = 1, messageServerId = "uid1")
+
+        assertThat(flags).isEmpty()
+    }
+
+    @Test
+    fun `get all message server ids and dates`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", date = 23)
+        sqliteDatabase.createMessage(folderId = 1, uid = "K9LOCAL:1")
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid3", date = 42)
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid4", deleted = true)
+
+        val result = retrieveMessageOperations.getAllMessagesAndEffectiveDates(folderId = 1)
+
+        assertThat(result).isEqualTo(
+            mapOf(
+                "uid1" to 23L,
+                "uid3" to 42L
+            )
+        )
+    }
+
+    @Test
+    fun `get headers`() {
+        val messagePartId = sqliteDatabase.createMessagePart(
+            header = """
+                From: <alice@domain.example>
+                To: Bob <bob@domain.example>
+                Date: Thu, 01 Apr 2021 01:23:45 +0200
+                Subject: Test
+                Message-Id: <20210401012345.123456789A@domain.example>
+            """.trimIndent().crlf()
+        )
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", messagePartId = messagePartId)
+
+        val headers = retrieveMessageOperations.getHeaders(folderId = 1, messageServerId = "uid1")
+
+        assertThat(headers).isEqualTo(
+            listOf(
+                Header("From", "<alice@domain.example>"),
+                Header("To", "Bob <bob@domain.example>"),
+                Header("Date", "Thu, 01 Apr 2021 01:23:45 +0200"),
+                Header("Subject", "Test"),
+                Header("Message-Id", "<20210401012345.123456789A@domain.example>")
+            )
+        )
+    }
+
+    @Test
+    fun `get some headers`() {
+        val messagePartId = sqliteDatabase.createMessagePart(
+            header = """
+                From: <alice@domain.example>
+                To: Bob <bob@domain.example>
+                Date: Thu, 01 Apr 2021 01:23:45 +0200
+                Subject: Test
+                Message-Id: <20210401012345.123456789A@domain.example>
+            """.trimIndent().crlf()
+        )
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", messagePartId = messagePartId)
+
+        val headers = retrieveMessageOperations.getHeaders(
+            folderId = 1,
+            messageServerId = "uid1",
+            headerNames = setOf("from", "to", "message-id")
+        )
+
+        assertThat(headers).isEqualTo(
+            listOf(
+                Header("From", "<alice@domain.example>"),
+                Header("To", "Bob <bob@domain.example>"),
+                Header("Message-Id", "<20210401012345.123456789A@domain.example>")
+            )
+        )
+    }
+
+    @Test
+    fun `get oldest message date`() {
+        sqliteDatabase.createMessage(folderId = 1, date = 42)
+        sqliteDatabase.createMessage(folderId = 1, date = 23)
+
+        val oldestMessageDate = retrieveMessageOperations.getOldestMessageDate(folderId = 1)
+
+        assertThat(oldestMessageDate).isEqualTo(Date(23))
+    }
+
+    @Test
+    fun `get oldest message date without any messages in the store`() {
+        val oldestMessageDate = retrieveMessageOperations.getOldestMessageDate(folderId = 1)
+
+        assertThat(oldestMessageDate).isNull()
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/SaveMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/SaveMessageOperationsTest.kt
new file mode 100644
index 0000000..b5b3f3e
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/SaveMessageOperationsTest.kt
@@ -0,0 +1,556 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.startsWith
+import com.fsck.k9.K9
+import com.fsck.k9.mail.Address
+import com.fsck.k9.mail.Flag
+import com.fsck.k9.mail.Message
+import com.fsck.k9.mail.MessageDownloadState
+import com.fsck.k9.mail.Multipart
+import com.fsck.k9.mail.Part
+import com.fsck.k9.mail.buildMessage
+import com.fsck.k9.mailstore.SaveMessageData
+import com.fsck.k9.mailstore.StorageManager
+import com.fsck.k9.message.extractors.BasicPartInfoExtractor
+import com.fsck.k9.message.extractors.PreviewResult
+import com.fsck.k9.storage.RobolectricTest
+import java.io.ByteArrayOutputStream
+import java.util.Stack
+import org.junit.After
+import org.junit.Test
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+
+private const val ACCOUNT_UUID = "00000000-0000-4000-0000-000000000000"
+
+class SaveMessageOperationsTest : RobolectricTest() {
+    private val messagePartDirectory = createRandomTempDirectory()
+    private val sqliteDatabase = createDatabase()
+    private val storageManager = mock<StorageManager> {
+        on { getAttachmentDirectory(eq(ACCOUNT_UUID), anyOrNull()) } doReturn messagePartDirectory
+    }
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val attachmentFileManager = AttachmentFileManager(storageManager, ACCOUNT_UUID)
+    private val basicPartInfoExtractor = BasicPartInfoExtractor()
+    private val threadMessageOperations = ThreadMessageOperations()
+    private val saveMessageOperations = SaveMessageOperations(
+        lockableDatabase,
+        attachmentFileManager,
+        basicPartInfoExtractor,
+        threadMessageOperations
+    )
+
+    @After
+    fun tearDown() {
+        messagePartDirectory.deleteRecursively()
+    }
+
+    @Test
+    fun `save message with text_plain body`() {
+        val messageData = buildMessage {
+            header("Subject", "Test Message")
+            header("From", "alice@domain.example")
+            header("To", "Bob <bob@domain.example>")
+            header("Cc", "<cloe@domain.example>")
+            header("Date", "Mon, 12 Apr 2021 03:42:00 +0200")
+            header("Message-ID", "<msg0001@domain.example>")
+
+            textBody("Text")
+        }.apply {
+            setFlag(Flag.FLAGGED, true)
+            setFlag(Flag.SEEN, true)
+            setFlag(Flag.ANSWERED, true)
+            setFlag(Flag.FORWARDED, true)
+        }.toSaveMessageData(
+            previewResult = PreviewResult.text("Preview")
+        )
+
+        saveMessageOperations.saveRemoteMessage(folderId = 1, messageServerId = "uid1", messageData)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+        val message = messages.first()
+        with(message) {
+            assertThat(deleted).isEqualTo(0)
+            assertThat(folderId).isEqualTo(1)
+            assertThat(uid).isEqualTo("uid1")
+            assertThat(subject).isEqualTo("Test Message")
+            assertThat(date).isEqualTo(1618191720000L)
+            assertThat(internalDate).isEqualTo(1618191720000L)
+            assertThat(flags).isEqualTo("X_DOWNLOADED_FULL")
+            assertThat(senderList).isEqualTo("alice@domain.example")
+            assertThat(toList).isEqualTo(Address.pack(Address.parse("Bob <bob@domain.example>")))
+            assertThat(ccList).isEqualTo("cloe@domain.example")
+            assertThat(bccList).isEqualTo("")
+            assertThat(replyToList).isEqualTo("")
+            assertThat(attachmentCount).isEqualTo(0)
+            assertThat(messageId).isEqualTo("<msg0001@domain.example>")
+            assertThat(previewType).isEqualTo("text")
+            assertThat(preview).isEqualTo("Preview")
+            assertThat(mimeType).isEqualTo("text/plain")
+            assertThat(empty).isEqualTo(0)
+            assertThat(read).isEqualTo(1)
+            assertThat(flagged).isEqualTo(1)
+            assertThat(answered).isEqualTo(1)
+            assertThat(forwarded).isEqualTo(1)
+            assertThat(encryptionType).isNull()
+        }
+
+        val messageParts = sqliteDatabase.readMessageParts()
+        assertThat(messageParts).hasSize(1)
+        val messagePart = messageParts.first()
+        with(messagePart) {
+            assertThat(type).isEqualTo(MessagePartType.UNKNOWN)
+            assertThat(root).isEqualTo(messagePart.id)
+            assertThat(parent).isEqualTo(-1)
+            assertThat(seq).isEqualTo(0)
+            assertThat(mimeType).isEqualTo("text/plain")
+            assertThat(displayName).isEqualTo("noname.txt")
+            assertThat(header?.toString(Charsets.UTF_8)).isEqualTo(messageData.message.header())
+            assertThat(encoding).isEqualTo("quoted-printable")
+            assertThat(charset).isNull()
+            assertThat(dataLocation).isEqualTo(DataLocation.IN_DATABASE)
+            assertThat(decodedBodySize).isEqualTo(4)
+            assertThat(data?.toString(Charsets.UTF_8)).isEqualTo("Text")
+            assertThat(preamble).isNull()
+            assertThat(epilogue).isNull()
+            assertThat(boundary).isNull()
+            assertThat(contentId).isNull()
+            assertThat(serverExtra).isNull()
+        }
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(1)
+        val thread = threads.first()
+        with(thread) {
+            assertThat(messageId).isEqualTo(message.id)
+            assertThat(root).isEqualTo(id)
+            assertThat(parent).isNull()
+        }
+    }
+
+    @Test
+    fun `save message with multipart body`() {
+        val messageData = buildMessage {
+            multipart("alternative") {
+                bodyPart("text/plain") {
+                    textBody("plain")
+                }
+                bodyPart("text/html") {
+                    textBody("html")
+                }
+            }
+        }.toSaveMessageData()
+
+        saveMessageOperations.saveRemoteMessage(folderId = 1, messageServerId = "uid1", messageData)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        val messageParts = sqliteDatabase.readMessageParts()
+        assertThat(messageParts).hasSize(3)
+
+        val rootMessagePart = messageParts.first { it.seq == 0 }
+        with(rootMessagePart) {
+            assertThat(type).isEqualTo(MessagePartType.UNKNOWN)
+            assertThat(root).isEqualTo(id)
+            assertThat(parent).isEqualTo(-1)
+            assertThat(mimeType).isEqualTo("multipart/alternative")
+            assertThat(displayName).isNull()
+            assertThat(header?.toString(Charsets.UTF_8)).isEqualTo(messageData.message.header())
+            assertThat(encoding).isNull()
+            assertThat(charset).isNull()
+            assertThat(dataLocation).isEqualTo(DataLocation.CHILD_PART_CONTAINS_DATA)
+            assertThat(decodedBodySize).isNull()
+            assertThat(data).isNull()
+            assertThat(preamble).isNull()
+            assertThat(epilogue).isNull()
+            assertThat(boundary).isEqualTo(messageData.message.boundary())
+            assertThat(contentId).isNull()
+            assertThat(serverExtra).isNull()
+        }
+
+        val textPlainMessagePart = messageParts.first { it.seq == 1 }
+        with(textPlainMessagePart) {
+            assertThat(type).isEqualTo(MessagePartType.UNKNOWN)
+            assertThat(root).isEqualTo(rootMessagePart.id)
+            assertThat(parent).isEqualTo(rootMessagePart.id)
+            assertThat(mimeType).isEqualTo("text/plain")
+            assertThat(displayName).isEqualTo("noname.txt")
+            assertThat(header).isNotNull()
+            assertThat(encoding).isEqualTo("quoted-printable")
+            assertThat(charset).isNull()
+            assertThat(dataLocation).isEqualTo(DataLocation.IN_DATABASE)
+            assertThat(decodedBodySize).isEqualTo(5)
+            assertThat(data?.toString(Charsets.UTF_8)).isEqualTo("plain")
+            assertThat(preamble).isNull()
+            assertThat(epilogue).isNull()
+            assertThat(boundary).isNull()
+            assertThat(contentId).isNull()
+            assertThat(serverExtra).isNull()
+        }
+
+        val textHtmlMessagePart = messageParts.first { it.seq == 2 }
+        with(textHtmlMessagePart) {
+            assertThat(type).isEqualTo(MessagePartType.UNKNOWN)
+            assertThat(root).isEqualTo(rootMessagePart.id)
+            assertThat(parent).isEqualTo(rootMessagePart.id)
+            assertThat(mimeType).isEqualTo("text/html")
+            assertThat(displayName).isEqualTo("noname.html")
+            assertThat(header).isNotNull()
+            assertThat(encoding).isEqualTo("quoted-printable")
+            assertThat(charset).isNull()
+            assertThat(dataLocation).isEqualTo(DataLocation.IN_DATABASE)
+            assertThat(decodedBodySize).isEqualTo(4)
+            assertThat(data?.toString(Charsets.UTF_8)).isEqualTo("html")
+            assertThat(preamble).isNull()
+            assertThat(epilogue).isNull()
+            assertThat(boundary).isNull()
+            assertThat(contentId).isNull()
+            assertThat(serverExtra).isNull()
+        }
+    }
+
+    @Test
+    fun `save message into existing thread`() {
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = true,
+            messageIdHeader = "<msg0001@domain.example>"
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = true,
+            messageIdHeader = "<msg0002@domain.example>"
+        )
+        val messageId3 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = false,
+            messageIdHeader = "<msg0003@domain.example>"
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val threadId2 = sqliteDatabase.createThread(messageId2, root = threadId1, parent = threadId1)
+        val threadId3 = sqliteDatabase.createThread(messageId3, root = threadId1, parent = threadId2)
+        val messageData = buildMessage {
+            header("Message-ID", "<msg0002@domain.example>")
+            header("In-Reply-To", "<msg0001@domain.example>")
+
+            textBody()
+        }.toSaveMessageData()
+
+        saveMessageOperations.saveRemoteMessage(folderId = 1, messageServerId = "uid1", messageData)
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(3)
+
+        assertThat(threads.first { it.id == threadId1 }).isEqualTo(
+            ThreadEntry(
+                id = threadId1,
+                messageId = messageId1,
+                root = threadId1,
+                parent = null
+            )
+        )
+
+        assertThat(threads.first { it.id == threadId2 }).isEqualTo(
+            ThreadEntry(
+                id = threadId2,
+                messageId = messageId2,
+                root = threadId1,
+                parent = threadId1
+            )
+        )
+
+        assertThat(threads.first { it.id == threadId3 }).isEqualTo(
+            ThreadEntry(
+                id = threadId3,
+                messageId = messageId3,
+                root = threadId1,
+                parent = threadId2
+            )
+        )
+    }
+
+    @Test
+    fun `save message with references header should create empty messages`() {
+        val messageData = buildMessage {
+            header("Message-ID", "<msg0003@domain.example>")
+            header("In-Reply-To", "<msg0002@domain.example>")
+            header("References", "<msg0001@domain.example> <msg0002@domain.example>")
+
+            textBody()
+        }.toSaveMessageData()
+
+        saveMessageOperations.saveRemoteMessage(folderId = 1, messageServerId = "uid1", messageData)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(3)
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(3)
+
+        val thread1 = threads.first { it.id == it.root }
+        val message1 = messages.first { it.id == thread1.messageId }
+        assertThat(message1.empty).isEqualTo(1)
+
+        val thread2 = threads.first { it.parent == thread1.id }
+        val message2 = messages.first { it.id == thread2.messageId }
+        assertThat(message2.empty).isEqualTo(1)
+
+        val thread3 = threads.first { it.parent == thread2.id }
+        val message3 = messages.first { it.id == thread3.messageId }
+        assertThat(message3.empty).isEqualTo(0)
+        assertThat(message3.uid).isEqualTo("uid1")
+    }
+
+    @Test
+    fun `save message with server ID already existing in MessageStore should replace that message`() {
+        val existingMessageData = buildMessage {
+            multipart("alternative") {
+                bodyPart("text/plain") {
+                    textBody("plain")
+                }
+                bodyPart("text/html") {
+                    textBody("html")
+                }
+            }
+        }.toSaveMessageData()
+        saveMessageOperations.saveRemoteMessage(folderId = 1, messageServerId = "uid1", existingMessageData)
+        val messageData = buildMessage {
+            textBody("new")
+        }.toSaveMessageData()
+
+        saveMessageOperations.saveRemoteMessage(folderId = 1, messageServerId = "uid1", messageData)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        val messageParts = sqliteDatabase.readMessageParts()
+        assertThat(messageParts).hasSize(1)
+
+        val messagePart = messageParts.first()
+        with(messagePart) {
+            assertThat(type).isEqualTo(MessagePartType.UNKNOWN)
+            assertThat(root).isEqualTo(messagePart.id)
+            assertThat(parent).isEqualTo(-1)
+            assertThat(mimeType).isEqualTo("text/plain")
+            assertThat(displayName).isEqualTo("noname.txt")
+            assertThat(header).isNotNull()
+            assertThat(encoding).isEqualTo("quoted-printable")
+            assertThat(charset).isNull()
+            assertThat(dataLocation).isEqualTo(DataLocation.IN_DATABASE)
+            assertThat(decodedBodySize).isEqualTo(3)
+            assertThat(data?.toString(Charsets.UTF_8)).isEqualTo("new")
+            assertThat(preamble).isNull()
+            assertThat(epilogue).isNull()
+            assertThat(boundary).isNull()
+            assertThat(contentId).isNull()
+            assertThat(serverExtra).isNull()
+        }
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(1)
+
+        val thread = threads.first()
+        val message = messages.first()
+        assertThat(thread.root).isEqualTo(thread.id)
+        assertThat(thread.parent).isNull()
+        assertThat(thread.messageId).isEqualTo(message.id)
+    }
+
+    @Test
+    fun `save local message`() {
+        val messageData = buildMessage {
+            textBody("local")
+        }.toSaveMessageData(
+            subject = "Provided subject",
+            date = 1618191720000L,
+            internalDate = 1618191720000L,
+            previewResult = PreviewResult.text("Preview")
+        )
+
+        val newMessageId = saveMessageOperations.saveLocalMessage(folderId = 1, messageData, existingMessageId = null)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        val message = messages.first()
+        with(message) {
+            assertThat(id).isEqualTo(newMessageId)
+            assertThat(deleted).isEqualTo(0)
+            assertThat(folderId).isEqualTo(1)
+            assertThat(uid).isNotNull().startsWith(K9.LOCAL_UID_PREFIX)
+            assertThat(subject).isEqualTo("Provided subject")
+            assertThat(date).isEqualTo(1618191720000L)
+            assertThat(internalDate).isEqualTo(1618191720000L)
+            assertThat(flags).isEqualTo("X_DOWNLOADED_FULL")
+            assertThat(senderList).isEqualTo("")
+            assertThat(toList).isEqualTo("")
+            assertThat(ccList).isEqualTo("")
+            assertThat(bccList).isEqualTo("")
+            assertThat(replyToList).isEqualTo("")
+            assertThat(attachmentCount).isEqualTo(0)
+            assertThat(messageId).isNull()
+            assertThat(previewType).isEqualTo("text")
+            assertThat(preview).isEqualTo("Preview")
+            assertThat(mimeType).isEqualTo("text/plain")
+            assertThat(empty).isEqualTo(0)
+            assertThat(read).isEqualTo(0)
+            assertThat(flagged).isEqualTo(0)
+            assertThat(answered).isEqualTo(0)
+            assertThat(forwarded).isEqualTo(0)
+            assertThat(encryptionType).isNull()
+        }
+
+        val messageParts = sqliteDatabase.readMessageParts()
+        assertThat(messageParts).hasSize(1)
+
+        val messagePart = messageParts.first()
+        with(messagePart) {
+            assertThat(type).isEqualTo(MessagePartType.UNKNOWN)
+            assertThat(root).isEqualTo(messagePart.id)
+            assertThat(parent).isEqualTo(-1)
+            assertThat(mimeType).isEqualTo("text/plain")
+            assertThat(displayName).isEqualTo("noname.txt")
+            assertThat(header).isNotNull()
+            assertThat(encoding).isEqualTo("quoted-printable")
+            assertThat(charset).isNull()
+            assertThat(dataLocation).isEqualTo(DataLocation.IN_DATABASE)
+            assertThat(decodedBodySize).isEqualTo(5)
+            assertThat(data?.toString(Charsets.UTF_8)).isEqualTo("local")
+            assertThat(preamble).isNull()
+            assertThat(epilogue).isNull()
+            assertThat(boundary).isNull()
+            assertThat(contentId).isNull()
+            assertThat(serverExtra).isNull()
+        }
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(1)
+
+        val thread = threads.first()
+        assertThat(thread.root).isEqualTo(thread.id)
+        assertThat(thread.parent).isNull()
+        assertThat(thread.messageId).isEqualTo(message.id)
+    }
+
+    @Test
+    fun `replace local message`() {
+        val existingMessageData = buildMessage {
+            multipart("alternative") {
+                bodyPart("text/plain") {
+                    textBody("plain")
+                }
+                bodyPart("text/html") {
+                    textBody("html")
+                }
+            }
+        }.toSaveMessageData()
+        val existingMessageId = saveMessageOperations.saveLocalMessage(
+            folderId = 1,
+            existingMessageData,
+            existingMessageId = null
+        )
+        val messageData = buildMessage {
+            textBody("new")
+        }.toSaveMessageData()
+
+        val newMessageId = saveMessageOperations.saveLocalMessage(folderId = 1, messageData, existingMessageId)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        assertThat(messages.first().id).isEqualTo(newMessageId)
+
+        val messageParts = sqliteDatabase.readMessageParts()
+        assertThat(messageParts).hasSize(1)
+
+        val messagePart = messageParts.first()
+        with(messagePart) {
+            assertThat(type).isEqualTo(MessagePartType.UNKNOWN)
+            assertThat(root).isEqualTo(messagePart.id)
+            assertThat(parent).isEqualTo(-1)
+            assertThat(mimeType).isEqualTo("text/plain")
+            assertThat(displayName).isEqualTo("noname.txt")
+            assertThat(header).isNotNull()
+            assertThat(encoding).isEqualTo("quoted-printable")
+            assertThat(charset).isNull()
+            assertThat(dataLocation).isEqualTo(DataLocation.IN_DATABASE)
+            assertThat(decodedBodySize).isEqualTo(3)
+            assertThat(data?.toString(Charsets.UTF_8)).isEqualTo("new")
+            assertThat(preamble).isNull()
+            assertThat(epilogue).isNull()
+            assertThat(boundary).isNull()
+            assertThat(contentId).isNull()
+            assertThat(serverExtra).isNull()
+        }
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(1)
+
+        val thread = threads.first()
+        val message = messages.first()
+        assertThat(thread.root).isEqualTo(thread.id)
+        assertThat(thread.parent).isNull()
+        assertThat(thread.messageId).isEqualTo(message.id)
+    }
+
+    private fun Message.toSaveMessageData(
+        subject: String? = getSubject(),
+        date: Long = sentDate?.time ?: System.currentTimeMillis(),
+        internalDate: Long = date,
+        downloadState: MessageDownloadState = getDownloadState(),
+        attachmentCount: Int = 0,
+        previewResult: PreviewResult = PreviewResult.none(),
+        textForSearchIndex: String? = null,
+        encryptionType: String? = null
+    ): SaveMessageData {
+        return SaveMessageData(
+            message = this,
+            subject,
+            date,
+            internalDate,
+            downloadState,
+            attachmentCount,
+            previewResult,
+            textForSearchIndex,
+            encryptionType
+        )
+    }
+
+    private fun Message.getDownloadState(): MessageDownloadState {
+        if (body == null) return MessageDownloadState.ENVELOPE
+
+        val stack = Stack<Part>()
+        stack.push(this)
+
+        while (stack.isNotEmpty()) {
+            val part = stack.pop()
+            when (val body = part.body) {
+                null -> return MessageDownloadState.PARTIAL
+                is Multipart -> {
+                    for (i in 0 until body.count) {
+                        stack.push(body.getBodyPart(i))
+                    }
+                }
+            }
+        }
+
+        return MessageDownloadState.FULL
+    }
+
+    private fun Message.header(): String {
+        val outputStream = ByteArrayOutputStream()
+        writeHeaderTo(outputStream)
+        return outputStream.toString("UTF-8")
+    }
+
+    private fun Message.boundary(): String? = (body as Multipart).boundary
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/ThreadDatabaseHelpers.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/ThreadDatabaseHelpers.kt
new file mode 100644
index 0000000..31831f1
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/ThreadDatabaseHelpers.kt
@@ -0,0 +1,40 @@
+package com.fsck.k9.storage.messages
+
+import android.content.ContentValues
+import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.android.common.database.getLongOrNull
+import app.k9mail.core.android.common.database.map
+
+fun SQLiteDatabase.createThread(
+    messageId: Long,
+    root: Long? = null,
+    parent: Long? = null
+): Long {
+    val values = ContentValues().apply {
+        put("message_id", messageId)
+        put("root", root)
+        put("parent", parent)
+    }
+
+    return insert("threads", null, values)
+}
+
+fun SQLiteDatabase.readThreads(): List<ThreadEntry> {
+    return rawQuery("SELECT * FROM threads", null).use { cursor ->
+        cursor.map {
+            ThreadEntry(
+                id = cursor.getLongOrNull("id"),
+                messageId = cursor.getLongOrNull("message_id"),
+                root = cursor.getLongOrNull("root"),
+                parent = cursor.getLongOrNull("parent")
+            )
+        }
+    }
+}
+
+data class ThreadEntry(
+    val id: Long?,
+    val messageId: Long?,
+    val root: Long?,
+    val parent: Long?
+)
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/ThreadMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/ThreadMessageOperationsTest.kt
new file mode 100644
index 0000000..658cfb6
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/ThreadMessageOperationsTest.kt
@@ -0,0 +1,266 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class ThreadMessageOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val threadMessageOperations = ThreadMessageOperations()
+
+    @Test
+    fun `insert message without existing thread`() {
+        val threadInfo = threadMessageOperations.doMessageThreading(
+            sqliteDatabase,
+            folderId = 1,
+            ThreadHeaders(messageIdHeader = "<msg001@domain.example>", inReplyToHeader = null, referencesHeader = null)
+        )
+
+        assertThat(threadInfo).isNull()
+
+        assertThat(sqliteDatabase.readThreads()).isEmpty()
+    }
+
+    @Test
+    fun `insert message with in-reply-to header without existing thread`() {
+        val threadInfo = threadMessageOperations.doMessageThreading(
+            sqliteDatabase,
+            folderId = 1,
+            ThreadHeaders(
+                messageIdHeader = "<msg002@domain.example>",
+                inReplyToHeader = "<msg001@domain.example>",
+                referencesHeader = null
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(1)
+
+        val rootThread = threads.first { it.id == it.root }
+        assertThat(rootThread.parent).isNull()
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        val emptyMessage = messages.first()
+        assertThat(emptyMessage.id).isEqualTo(rootThread.messageId)
+        assertThat(emptyMessage.empty).isEqualTo(1)
+        assertThat(emptyMessage.messageId).isEqualTo("<msg001@domain.example>")
+
+        assertThat(threadInfo).isEqualTo(
+            ThreadInfo(
+                threadId = null,
+                messageId = null,
+                rootId = rootThread.id!!,
+                parentId = rootThread.id
+            )
+        )
+    }
+
+    @Test
+    fun `insert message with in-reply-to header into existing thread`() {
+        val messageId = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = false,
+            messageIdHeader = "<msg001@domain.example>"
+        )
+        val threadId = sqliteDatabase.createThread(messageId)
+
+        val threadInfo = threadMessageOperations.doMessageThreading(
+            sqliteDatabase,
+            folderId = 1,
+            ThreadHeaders(
+                messageIdHeader = "<msg002@domain.example>",
+                inReplyToHeader = "<msg001@domain.example>",
+                referencesHeader = null
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(1)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        assertThat(threadInfo).isEqualTo(
+            ThreadInfo(
+                threadId = null,
+                messageId = null,
+                rootId = threadId,
+                parentId = threadId
+            )
+        )
+    }
+
+    @Test
+    fun `insert message into existing thread as thread root`() {
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = true,
+            messageIdHeader = "<msg001@domain.example>"
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = 1,
+            empty = false,
+            messageIdHeader = "<msg002@domain.example>"
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        sqliteDatabase.createThread(messageId2, root = threadId1, parent = threadId1)
+
+        val threadInfo = threadMessageOperations.doMessageThreading(
+            sqliteDatabase,
+            folderId = 1,
+            ThreadHeaders(
+                messageIdHeader = "<msg001@domain.example>",
+                inReplyToHeader = null,
+                referencesHeader = null
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(2)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(2)
+
+        assertThat(threadInfo).isEqualTo(
+            ThreadInfo(
+                threadId = threadId1,
+                messageId = messageId1,
+                rootId = threadId1,
+                parentId = null
+            )
+        )
+    }
+
+    @Test
+    fun `insert message into existing thread changing the thread root`() {
+        val messageId1 = sqliteDatabase.createMessage(
+            folderId = 1,
+            messageIdHeader = "<msg001@domain.example>",
+            empty = true
+        )
+        val messageId2 = sqliteDatabase.createMessage(
+            folderId = 1,
+            messageIdHeader = "<msg002@domain.example>",
+            empty = true
+        )
+        val messageId3 = sqliteDatabase.createMessage(
+            folderId = 1,
+            messageIdHeader = "<msg003@domain.example>",
+            empty = false
+        )
+        val threadId1 = sqliteDatabase.createThread(messageId1)
+        val threadId2 = sqliteDatabase.createThread(messageId2, root = threadId1, parent = threadId1)
+        val threadId3 = sqliteDatabase.createThread(messageId3, root = threadId1, parent = threadId2)
+
+        val threadInfo = threadMessageOperations.doMessageThreading(
+            sqliteDatabase,
+            folderId = 1,
+            ThreadHeaders(
+                messageIdHeader = "<msg002@domain.example>",
+                inReplyToHeader = "<msg001@domain.example>",
+                referencesHeader = "<msg000@domain.example> <msg001@domain.example>"
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(4)
+
+        val newRootThread = threads.first { it.id !in setOf(threadId1, threadId2, threadId3) }
+        assertThat(newRootThread.root).isEqualTo(newRootThread.id)
+        assertThat(newRootThread.parent).isNull()
+
+        for (thread in threads) {
+            assertThat(thread.root).isEqualTo(newRootThread.id)
+        }
+
+        assertThat(threadInfo).isEqualTo(
+            ThreadInfo(
+                threadId = threadId2,
+                messageId = messageId2,
+                rootId = newRootThread.id!!,
+                parentId = threadId1
+            )
+        )
+    }
+
+    @Test
+    fun `merge two existing threads`() {
+        val messageIdB = sqliteDatabase.createMessage(
+            folderId = 1,
+            messageIdHeader = "<msgB@domain.example>",
+            empty = true
+        )
+        val messageIdC = sqliteDatabase.createMessage(
+            folderId = 1,
+            messageIdHeader = "<msgC@domain.example>",
+            empty = false
+        )
+        val messageIdD = sqliteDatabase.createMessage(
+            folderId = 1,
+            messageIdHeader = "<msgD@domain.example>",
+            empty = true
+        )
+        val messageIdE = sqliteDatabase.createMessage(
+            folderId = 1,
+            messageIdHeader = "<msgE@domain.example>",
+            empty = false
+        )
+        val threadIdB = sqliteDatabase.createThread(messageIdB)
+        val threadIdC = sqliteDatabase.createThread(messageIdC, root = threadIdB, parent = threadIdB)
+        val threadIdD = sqliteDatabase.createThread(messageIdD)
+        val threadIdE = sqliteDatabase.createThread(messageIdE, root = threadIdD, parent = threadIdD)
+
+        val threadInfo = threadMessageOperations.doMessageThreading(
+            sqliteDatabase,
+            folderId = 1,
+            ThreadHeaders(
+                messageIdHeader = "<msgD@domain.example>",
+                inReplyToHeader = "<msgC@domain.example>",
+                referencesHeader = "<msgA@domain.example>"
+            )
+        )
+
+        val threads = sqliteDatabase.readThreads()
+        assertThat(threads).hasSize(4 + 1)
+
+        val threadRoots = threads.filter { it.root == it.id }
+        assertThat(threadRoots).hasSize(1)
+
+        val threadA = threadRoots.first()
+        for (thread in threads) {
+            assertThat(thread.root).isEqualTo(threadA.id)
+        }
+
+        val messages = sqliteDatabase.readMessages()
+        val messageA = messages.first { it.id == threadA.messageId }
+        assertThat(messageA.empty).isEqualTo(1)
+        assertThat(messageA.messageId).isEqualTo("<msgA@domain.example>")
+
+        val threadB = threads.first { it.id == threadIdB }
+        assertThat(threadB.parent).isEqualTo(threadA.id)
+
+        val threadC = threads.first { it.id == threadIdC }
+        assertThat(threadC.parent).isEqualTo(threadB.id)
+
+        val threadD = threads.first { it.id == threadIdD }
+        assertThat(threadD.parent).isEqualTo(threadC.id)
+
+        val threadE = threads.first { it.id == threadIdE }
+        assertThat(threadE.parent).isEqualTo(threadD.id)
+
+        assertThat(threadInfo).isEqualTo(
+            ThreadInfo(
+                threadId = threadIdD,
+                messageId = messageIdD,
+                rootId = threadA.id!!,
+                parentId = threadIdC
+            )
+        )
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/UpdateFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/UpdateFolderOperationsTest.kt
new file mode 100644
index 0000000..86283f8
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/UpdateFolderOperationsTest.kt
@@ -0,0 +1,167 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.FolderClass
+import com.fsck.k9.mailstore.Folder
+import com.fsck.k9.mailstore.FolderDetails
+import com.fsck.k9.mailstore.FolderType
+import com.fsck.k9.mailstore.MoreMessages
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+import com.fsck.k9.mail.FolderType as RemoteFolderType
+
+class UpdateFolderOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val updateFolderOperations = UpdateFolderOperations(lockableDatabase)
+
+    @Test
+    fun `change folder`() {
+        sqliteDatabase.createFolder(serverId = "folder1", name = "Old", type = "REGULAR")
+
+        updateFolderOperations.changeFolder("folder1", "New", RemoteFolderType.TRASH)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.serverId).isEqualTo("folder1")
+        assertThat(folder.name).isEqualTo("New")
+        assertThat(folder.type).isEqualTo("trash")
+    }
+
+    @Test
+    fun `update folder settings`() {
+        val folderId = sqliteDatabase.createFolder(
+            inTopGroup = false,
+            integrate = false,
+            displayClass = "NO_CLASS",
+            syncClass = "NO_CLASS",
+            notifyClass = "NO_CLASS",
+            pushClass = "NO_CLASS"
+        )
+
+        updateFolderOperations.updateFolderSettings(
+            FolderDetails(
+                folder = Folder(
+                    id = folderId,
+                    name = "irrelevant",
+                    type = FolderType.REGULAR,
+                    isLocalOnly = false
+                ),
+                isInTopGroup = true,
+                isIntegrate = true,
+                displayClass = FolderClass.FIRST_CLASS,
+                syncClass = FolderClass.FIRST_CLASS,
+                notifyClass = FolderClass.FIRST_CLASS,
+                pushClass = FolderClass.FIRST_CLASS
+            )
+        )
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.inTopGroup).isEqualTo(1)
+        assertThat(folder.integrate).isEqualTo(1)
+        assertThat(folder.displayClass).isEqualTo("FIRST_CLASS")
+        assertThat(folder.syncClass).isEqualTo("FIRST_CLASS")
+        assertThat(folder.notifyClass).isEqualTo("FIRST_CLASS")
+        assertThat(folder.pushClass).isEqualTo("FIRST_CLASS")
+    }
+
+    @Test
+    fun `update integrate setting`() {
+        val folderId = sqliteDatabase.createFolder(integrate = false)
+
+        updateFolderOperations.setIncludeInUnifiedInbox(folderId = folderId, includeInUnifiedInbox = true)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.integrate).isEqualTo(1)
+    }
+
+    @Test
+    fun `update display class`() {
+        val folderId = sqliteDatabase.createFolder(displayClass = "FIRST_CLASS")
+
+        updateFolderOperations.setDisplayClass(folderId = folderId, folderClass = FolderClass.SECOND_CLASS)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.displayClass).isEqualTo("SECOND_CLASS")
+    }
+
+    @Test
+    fun `update sync class`() {
+        val folderId = sqliteDatabase.createFolder(syncClass = "FIRST_CLASS")
+
+        updateFolderOperations.setSyncClass(folderId = folderId, folderClass = FolderClass.NO_CLASS)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.syncClass).isEqualTo("NO_CLASS")
+    }
+
+    @Test
+    fun `update push class`() {
+        val folderId = sqliteDatabase.createFolder(pushClass = "FIRST_CLASS")
+
+        updateFolderOperations.setPushClass(folderId = folderId, folderClass = FolderClass.NO_CLASS)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.pushClass).isEqualTo("NO_CLASS")
+    }
+
+    @Test
+    fun `update notification class`() {
+        val folderId = sqliteDatabase.createFolder(syncClass = "FIRST_CLASS")
+
+        updateFolderOperations.setNotificationClass(folderId = folderId, folderClass = FolderClass.INHERITED)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.notifyClass).isEqualTo("INHERITED")
+    }
+
+    @Test
+    fun `update more messages state`() {
+        val folderId = sqliteDatabase.createFolder(moreMessages = "unknown")
+
+        updateFolderOperations.setMoreMessages(folderId = folderId, moreMessages = MoreMessages.TRUE)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.moreMessages).isEqualTo("true")
+    }
+
+    @Test
+    fun `update late updated state`() {
+        val folderId = sqliteDatabase.createFolder(lastUpdated = 23)
+
+        updateFolderOperations.setLastChecked(folderId = folderId, timestamp = 42)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.lastUpdated).isEqualTo(42)
+    }
+
+    @Test
+    fun `update folder status`() {
+        val folderId = sqliteDatabase.createFolder(status = null)
+
+        updateFolderOperations.setStatus(folderId = folderId, status = "Sync error")
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.status).isEqualTo("Sync error")
+    }
+
+    @Test
+    fun `update visible limit`() {
+        val folderId = sqliteDatabase.createFolder(visibleLimit = 10)
+
+        updateFolderOperations.setVisibleLimit(folderId = folderId, visibleLimit = 25)
+
+        val folder = sqliteDatabase.readFolders().first()
+        assertThat(folder.id).isEqualTo(folderId)
+        assertThat(folder.visibleLimit).isEqualTo(25)
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/UpdateMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/UpdateMessageOperationsTest.kt
new file mode 100644
index 0000000..8bc95c4
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/UpdateMessageOperationsTest.kt
@@ -0,0 +1,54 @@
+package com.fsck.k9.storage.messages
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import com.fsck.k9.storage.RobolectricTest
+import org.junit.Test
+
+class UpdateMessageOperationsTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val updateMessageOperations = UpdateMessageOperations(lockableDatabase)
+
+    @Test
+    fun `mark message as new`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", newMessage = false)
+
+        updateMessageOperations.setNewMessageState(folderId = 1, messageServerId = "uid1", newMessage = true)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        val message = messages.first()
+        assertThat(message.newMessage).isEqualTo(1)
+    }
+
+    @Test
+    fun `mark message as not new`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", newMessage = true)
+
+        updateMessageOperations.setNewMessageState(folderId = 1, messageServerId = "uid1", newMessage = false)
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(1)
+
+        val message = messages.first()
+        assertThat(message.newMessage).isEqualTo(0)
+    }
+
+    @Test
+    fun `clear new message state`() {
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", newMessage = true)
+        sqliteDatabase.createMessage(folderId = 1, uid = "uid1", newMessage = false)
+
+        updateMessageOperations.clearNewMessageState()
+
+        val messages = sqliteDatabase.readMessages()
+        assertThat(messages).hasSize(2)
+
+        for (message in messages) {
+            assertThat(message.newMessage).isEqualTo(0)
+        }
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/notifications/K9NotificationStoreTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/notifications/K9NotificationStoreTest.kt
new file mode 100644
index 0000000..108cd78
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/notifications/K9NotificationStoreTest.kt
@@ -0,0 +1,107 @@
+package com.fsck.k9.storage.notifications
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import com.fsck.k9.controller.MessageReference
+import com.fsck.k9.notification.NotificationStoreOperation
+import com.fsck.k9.storage.RobolectricTest
+import com.fsck.k9.storage.messages.createDatabase
+import com.fsck.k9.storage.messages.createLockableDatabaseMock
+import com.fsck.k9.storage.messages.createMessage
+import org.junit.Test
+
+private const val FOLDER_ID = 1L
+
+class K9NotificationStoreTest : RobolectricTest() {
+    private val sqliteDatabase = createDatabase()
+    private val lockableDatabase = createLockableDatabaseMock(sqliteDatabase)
+    private val store = K9NotificationStore(lockableDatabase)
+    private val messageIdOne = sqliteDatabase.createMessage(folderId = FOLDER_ID, uid = "uid-1")
+    private val messageIdTwo = sqliteDatabase.createMessage(folderId = FOLDER_ID, uid = "uid-2")
+
+    @Test
+    fun `add notification`() {
+        val operations = listOf(
+            NotificationStoreOperation.Add(
+                messageReference = createMessageReference("uid-1"),
+                notificationId = 42,
+                timestamp = 23L
+            )
+        )
+
+        store.persistNotificationChanges(operations)
+
+        val notifications = sqliteDatabase.readNotifications()
+        assertThat(notifications).hasSize(1)
+        val notification = notifications.first()
+        assertThat(notification.messageId).isEqualTo(messageIdOne)
+        assertThat(notification.notificationId).isEqualTo(42)
+        assertThat(notification.timestamp).isEqualTo(23L)
+    }
+
+    @Test
+    fun `replace notification when adding`() {
+        sqliteDatabase.createNotification(messageId = messageIdOne, notificationId = 10, timestamp = 20L)
+        val operations = listOf(
+            NotificationStoreOperation.ChangeToInactive(messageReference = createMessageReference("uid-1")),
+            NotificationStoreOperation.Add(
+                messageReference = createMessageReference("uid-2"),
+                notificationId = 10,
+                timestamp = 30L
+            )
+        )
+
+        store.persistNotificationChanges(operations)
+
+        val notifications = sqliteDatabase.readNotifications()
+        assertThat(notifications).hasSize(2)
+        val originalNotification = notifications.first { it.messageId == messageIdOne }
+        assertThat(originalNotification.notificationId).isNull()
+        assertThat(originalNotification.timestamp).isEqualTo(20L)
+        val newNotification = notifications.first { it.messageId == messageIdTwo }
+        assertThat(newNotification.notificationId).isEqualTo(10)
+        assertThat(newNotification.timestamp).isEqualTo(30L)
+    }
+
+    @Test
+    fun `remove notification`() {
+        sqliteDatabase.createNotification(messageId = messageIdOne, notificationId = 10, timestamp = 20L)
+        val operations = listOf(
+            NotificationStoreOperation.Remove(messageReference = createMessageReference("uid-1"))
+        )
+
+        store.persistNotificationChanges(operations)
+
+        val notifications = sqliteDatabase.readNotifications()
+        assertThat(notifications).isEmpty()
+    }
+
+    @Test
+    fun `replace notification when removing`() {
+        sqliteDatabase.createNotification(messageId = messageIdOne, notificationId = null, timestamp = 20L)
+        sqliteDatabase.createNotification(messageId = messageIdTwo, notificationId = 23, timestamp = 21L)
+        val operations = listOf(
+            NotificationStoreOperation.Remove(messageReference = createMessageReference("uid-2")),
+            NotificationStoreOperation.ChangeToActive(
+                messageReference = createMessageReference("uid-1"),
+                notificationId = 23
+            )
+        )
+
+        store.persistNotificationChanges(operations)
+
+        val notifications = sqliteDatabase.readNotifications()
+        assertThat(notifications).hasSize(1)
+        val notification = notifications.first()
+        assertThat(notification.messageId).isEqualTo(messageIdOne)
+        assertThat(notification.notificationId).isEqualTo(23)
+        assertThat(notification.timestamp).isEqualTo(20L)
+    }
+
+    private fun createMessageReference(uid: String): MessageReference {
+        return MessageReference(accountUuid = "00000000-0000-4000-0000-000000000000", FOLDER_ID, uid)
+    }
+}
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/notifications/NotificationsTableHelpers.kt b/app/storage/src/test/java/com/fsck/k9/storage/notifications/NotificationsTableHelpers.kt
new file mode 100644
index 0000000..a2780e6
--- /dev/null
+++ b/app/storage/src/test/java/com/fsck/k9/storage/notifications/NotificationsTableHelpers.kt
@@ -0,0 +1,40 @@
+package com.fsck.k9.storage.notifications
+
+import android.content.ContentValues
+import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.android.common.database.getIntOrNull
+import app.k9mail.core.android.common.database.getLongOrNull
+import app.k9mail.core.android.common.database.map
+
+fun SQLiteDatabase.createNotification(
+    messageId: Long,
+    notificationId: Int? = null,
+    timestamp: Long = 0L
+): Long {
+    val values = ContentValues().apply {
+        put("message_id", messageId)
+        put("notification_id", notificationId)
+        put("timestamp", timestamp)
+    }
+
+    return insert("notifications", null, values)
+}
+
+fun SQLiteDatabase.readNotifications(): List<NotificationEntry> {
+    val cursor = rawQuery("SELECT * FROM notifications", null)
+    return cursor.use {
+        cursor.map {
+            NotificationEntry(
+                messageId = cursor.getLongOrNull("message_id"),
+                notificationId = cursor.getIntOrNull("notification_id"),
+                timestamp = cursor.getLongOrNull("timestamp")
+            )
+        }
+    }
+}
+
+data class NotificationEntry(
+    val messageId: Long?,
+    val notificationId: Int?,
+    val timestamp: Long?
+)