@marcoappio/marco-config 2.0.504 → 2.0.505

package/dist/zero/mutators/threadMutators/threadMutators.test.js

@@ -0,0 +1,755 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { createMutators } from '../mutators';
+describe('threadMutators', () => {
+    describe('addLabel', () => {
+        it('adds label to thread', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const labelRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-label-id-1',
+                path: 'Work',
+            };
+            const messageRecords = [{ id: 'test-message-id-1' }, { id: 'test-message-id-2' }];
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => labelRecord);
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereLabelPath = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereLabelPath }));
+            const runMessages = mock(async () => messageRecords);
+            const whereMessages = mock(() => ({ run: runMessages }));
+            const runExisting = mock(async () => null);
+            const oneExisting = mock(() => ({ run: runExisting }));
+            const whereLabelId = mock(() => ({ one: oneExisting }));
+            const runAllThreadLabels = mock(async () => [{ labelId: 'test-label-id-1', threadId: 'test-thread-id-1' }]);
+            const whereThreadLabel = mock((field) => {
+                if (field === 'threadId') {
+                    return { run: runAllThreadLabels, where: whereLabelId };
+                }
+                if (field === 'threadMessageId') {
+                    return { where: whereLabelId };
+                }
+                return { where: whereLabelId };
+            });
+            const threadLabelInsert = mock(async () => { });
+            const threadUpdate = mock(async () => { });
+            const threadByLabelInsert = mock(async () => { });
+            const runThreadByLabel = mock(async () => null);
+            const oneThreadByLabel = mock(() => ({ run: runThreadByLabel }));
+            const whereThreadByLabelThreadId = mock(() => ({ one: oneThreadByLabel }));
+            const whereThreadByLabel = mock(() => ({ where: whereThreadByLabelThreadId }));
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: mock(async () => { }),
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                    threadByLabel: {
+                        delete: mock(async () => { }),
+                        insert: threadByLabelInsert,
+                    },
+                    threadLabel: {
+                        delete: mock(async () => { }),
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadByLabel: {
+                        where: whereThreadByLabel,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                    threadMessage: {
+                        where: whereMessages,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.addLabel(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+                labelPath: 'Work',
+            });
+            expect(threadLabelInsert).toHaveBeenCalledTimes(2);
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
+                accountId: 'test-account-id-1',
+                labelId: 'test-label-id-1',
+                threadId: 'test-thread-id-1',
+                threadMessageId: 'test-message-id-1',
+            }));
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
+                accountId: 'test-account-id-1',
+                labelId: 'test-label-id-1',
+                threadId: 'test-thread-id-1',
+                threadMessageId: 'test-message-id-2',
+            }));
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+                labelIdList: ' test-label-id-1 ',
+            });
+        });
+    });
+    describe('delete', () => {
+        it('deletes threads and decrements unread counts for unread threads', async () => {
+            const threadDelete = mock(async () => { });
+            const labelUpdate = mock(async () => { });
+            const threads = [
+                { id: 'test-thread-id-1', labelIdList: ' test-label-id-1 ', seen: false },
+                { id: 'test-thread-id-2', labelIdList: ' test-label-id-1 ', seen: true },
+            ];
+            const labels = [{ id: 'test-label-id-1', unreadCount: 5 }];
+            const runThread = mock(async (id) => threads.find(x => x.id === id));
+            const oneThread = mock(() => ({ run: () => runThread(whereThreadId) }));
+            let whereThreadId = '';
+            const whereThread = mock((_field, id) => {
+                whereThreadId = id;
+                return { one: oneThread };
+            });
+            const runLabels = mock(async () => labels);
+            const whereLabels = mock(() => ({ run: runLabels }));
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: labelUpdate,
+                    },
+                    thread: {
+                        delete: threadDelete,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabels,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.delete(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1', 'test-thread-id-2'] } },
+            });
+            expect(threadDelete).toHaveBeenCalledTimes(2);
+            expect(threadDelete).toHaveBeenCalledWith({ id: 'test-thread-id-1' });
+            expect(threadDelete).toHaveBeenCalledWith({ id: 'test-thread-id-2' });
+            expect(labelUpdate).toHaveBeenCalledTimes(1);
+            expect(labelUpdate).toHaveBeenCalledWith({
+                id: 'test-label-id-1',
+                unreadCount: 4,
+            });
+        });
+        it('does not update unread counts when deleting read threads', async () => {
+            const threadDelete = mock(async () => { });
+            const labelUpdate = mock(async () => { });
+            const thread = { id: 'test-thread-id-1', labelIdList: ' test-label-id-1 ', seen: true };
+            const runThread = mock(async () => thread);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: labelUpdate,
+                    },
+                    thread: {
+                        delete: threadDelete,
+                    },
+                },
+                query: {
+                    thread: {
+                        where: whereThread,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.delete(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+            });
+            expect(threadDelete).toHaveBeenCalledTimes(1);
+            expect(labelUpdate).not.toHaveBeenCalled();
+        });
+        it('handles non-existent threads gracefully', async () => {
+            const threadDelete = mock(async () => { });
+            const runThread = mock(async () => null);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const transaction = {
+                mutate: {
+                    thread: {
+                        delete: threadDelete,
+                    },
+                },
+                query: {
+                    thread: {
+                        where: whereThread,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.delete(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['non-existent-thread'] } },
+            });
+            expect(threadDelete).not.toHaveBeenCalled();
+        });
+    });
+    describe('removeLabel', () => {
+        it('removes label from thread', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+                labelIdList: ' test-label-id-1 ',
+            };
+            const labelRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-label-id-1',
+                path: 'Work',
+            };
+            const messageRecords = [{ id: 'test-message-id-1' }, { id: 'test-message-id-2' }];
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => labelRecord);
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereLabelPath = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereLabelPath }));
+            const runMessages = mock(async () => messageRecords);
+            const whereMessages = mock(() => ({ run: runMessages }));
+            const threadLabelDelete = mock(async () => { });
+            const threadUpdate = mock(async () => { });
+            const threadByLabelDelete = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: mock(async () => { }),
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                    threadByLabel: {
+                        delete: threadByLabelDelete,
+                    },
+                    threadLabel: {
+                        delete: threadLabelDelete,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadMessage: {
+                        where: whereMessages,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.removeLabel(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+                labelPath: 'Work',
+            });
+            expect(threadLabelDelete).toHaveBeenCalledTimes(2);
+            expect(threadLabelDelete).toHaveBeenCalledWith({
+                accountId: 'test-account-id-1',
+                labelId: 'test-label-id-1',
+                threadMessageId: 'test-message-id-1',
+            });
+            expect(threadLabelDelete).toHaveBeenCalledWith({
+                accountId: 'test-account-id-1',
+                labelId: 'test-label-id-1',
+                threadMessageId: 'test-message-id-2',
+            });
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+                labelIdList: '',
+            });
+        });
+    });
+    describe('setArchive', () => {
+        it('archives thread', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+                labelIdList: ' test-inbox-label-id ',
+            };
+            const archiveLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-archive-label-id',
+                specialUse: 'ARCHIVE',
+            };
+            const messageRecords = [{ id: 'test-message-id-1' }];
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => archiveLabel);
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const runLabelsToUpdate = mock(async () => [{ id: 'test-inbox-label-id', unreadCount: 1 }]);
+            const whereLabelAccount = mock((field) => {
+                if (field === 'id') {
+                    return { run: runLabelsToUpdate };
+                }
+                return { where: whereSpecialUse };
+            });
+            const runMessages = mock(async () => messageRecords);
+            const whereMessages = mock(() => ({ run: runMessages }));
+            const threadLabelDelete = mock(async () => { });
+            const threadLabelInsert = mock(async () => { });
+            const threadUpdate = mock(async () => { });
+            const threadByLabelDelete = mock(async () => { });
+            const threadByLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: mock(async () => { }),
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                    threadByLabel: {
+                        delete: threadByLabelDelete,
+                        insert: threadByLabelInsert,
+                    },
+                    threadLabel: {
+                        delete: threadLabelDelete,
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadMessage: {
+                        where: whereMessages,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setArchive(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+            });
+            expect(threadLabelDelete).toHaveBeenCalledWith({
+                accountId: 'test-account-id-1',
+                labelId: 'test-inbox-label-id',
+                threadMessageId: 'test-message-id-1',
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
+                accountId: 'test-account-id-1',
+                labelId: 'test-archive-label-id',
+                threadId: 'test-thread-id-1',
+                threadMessageId: 'test-message-id-1',
+            }));
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+                labelIdList: ' test-archive-label-id ',
+            });
+        });
+    });
+    describe('setFlagged', () => {
+        it('sets thread flagged status', async () => {
+            const threadUpdate = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    thread: {
+                        update: threadUpdate,
+                    },
+                },
+                query: {},
+            };
+            const mutators = createMutators();
+            await mutators.thread.setFlagged(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+                flagged: true,
+            });
+            expect(threadUpdate).toHaveBeenCalledWith({
+                flagged: true,
+                id: 'test-thread-id-1',
+            });
+        });
+    });
+    describe('setInbox', () => {
+        it('moves thread to inbox', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+                labelIdList: ' test-archive-label-id ',
+            };
+            const inboxLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-inbox-label-id',
+                specialUse: 'INBOX',
+            };
+            const messageRecords = [{ id: 'test-message-id-1' }];
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runLabel = mock(async () => inboxLabel);
+            const oneLabel = mock(() => ({ run: runLabel }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const runLabelsToUpdate = mock(async () => [{ id: 'test-archive-label-id', unreadCount: 1 }]);
+            const whereLabelAccount = mock((field) => {
+                if (field === 'id') {
+                    return { run: runLabelsToUpdate };
+                }
+                return { where: whereSpecialUse };
+            });
+            const runMessages = mock(async () => messageRecords);
+            const whereMessages = mock(() => ({ run: runMessages }));
+            const threadLabelDelete = mock(async () => { });
+            const threadLabelInsert = mock(async () => { });
+            const threadUpdate = mock(async () => { });
+            const threadByLabelDelete = mock(async () => { });
+            const threadByLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: mock(async () => { }),
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                    threadByLabel: {
+                        delete: threadByLabelDelete,
+                        insert: threadByLabelInsert,
+                    },
+                    threadLabel: {
+                        delete: threadLabelDelete,
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadMessage: {
+                        where: whereMessages,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setInbox(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+            });
+            expect(threadLabelDelete).toHaveBeenCalledWith({
+                accountId: 'test-account-id-1',
+                labelId: 'test-archive-label-id',
+                threadMessageId: 'test-message-id-1',
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
+                accountId: 'test-account-id-1',
+                labelId: 'test-inbox-label-id',
+                threadId: 'test-thread-id-1',
+                threadMessageId: 'test-message-id-1',
+            }));
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+                labelIdList: ' test-inbox-label-id ',
+            });
+        });
+    });
+    describe('setSeen', () => {
+        it('decrements unread count when marking unread threads as read', async () => {
+            const threadUpdate = mock(async () => { });
+            const labelUpdate = mock(async () => { });
+            const threads = [
+                { id: 'test-thread-id-1', labelIdList: ' test-inbox-label-id ', seen: false },
+                { id: 'test-thread-id-2', labelIdList: ' test-inbox-label-id ', seen: false },
+            ];
+            const labels = [{ id: 'test-inbox-label-id', specialUse: 'INBOX', unreadCount: 5 }];
+            const runThreads = mock(async () => threads);
+            const whereThread = mock(() => ({ run: runThreads }));
+            const runLabels = mock(async () => labels);
+            const whereLabel = mock(() => ({ run: runLabels }));
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: labelUpdate,
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabel,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setSeen(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1', 'test-thread-id-2'] } },
+                seen: true,
+            });
+            expect(threadUpdate).toHaveBeenCalledTimes(2);
+            expect(labelUpdate).toHaveBeenCalledWith({
+                id: 'test-inbox-label-id',
+                unreadCount: 3,
+            });
+        });
+        it('increments unread count when marking read threads as unread', async () => {
+            const threadUpdate = mock(async () => { });
+            const labelUpdate = mock(async () => { });
+            const threads = [{ id: 'test-thread-id-1', labelIdList: ' test-inbox-label-id ', seen: true }];
+            const labels = [{ id: 'test-inbox-label-id', specialUse: 'INBOX', unreadCount: 5 }];
+            const runThreads = mock(async () => threads);
+            const whereThread = mock(() => ({ run: runThreads }));
+            const runLabels = mock(async () => labels);
+            const whereLabel = mock(() => ({ run: runLabels }));
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: labelUpdate,
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabel,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setSeen(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+                seen: false,
+            });
+            expect(threadUpdate).toHaveBeenCalledTimes(1);
+            expect(labelUpdate).toHaveBeenCalledWith({
+                id: 'test-inbox-label-id',
+                unreadCount: 6,
+            });
+        });
+        it('skips label update when threads have no labels', async () => {
+            const threadUpdate = mock(async () => { });
+            const labelUpdate = mock(async () => { });
+            const threads = [{ id: 'test-thread-id-1', labelIdList: '', seen: false }];
+            const runThreads = mock(async () => threads);
+            const whereThread = mock(() => ({ run: runThreads }));
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: labelUpdate,
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                },
+                query: {
+                    thread: {
+                        where: whereThread,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setSeen(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+                seen: true,
+            });
+            expect(threadUpdate).toHaveBeenCalledTimes(1);
+            expect(labelUpdate).not.toHaveBeenCalled();
+        });
+        it('skips already-read threads when marking as read', async () => {
+            const threadUpdate = mock(async () => { });
+            const labelUpdate = mock(async () => { });
+            const threads = [{ id: 'test-thread-id-1', labelIdList: ' test-inbox-label-id ', seen: true }];
+            const runThreads = mock(async () => threads);
+            const whereThread = mock(() => ({ run: runThreads }));
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: labelUpdate,
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                },
+                query: {
+                    thread: {
+                        where: whereThread,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setSeen(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+                seen: true,
+            });
+            expect(threadUpdate).toHaveBeenCalledTimes(1);
+            expect(labelUpdate).not.toHaveBeenCalled();
+        });
+    });
+    describe('setSpam', () => {
+        it('marks thread as spam', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const spamLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-spam-label-id',
+                specialUse: 'SPAM',
+            };
+            const messageRecords = [{ id: 'test-message-id-1' }];
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runSpam = mock(async () => spamLabel);
+            const oneLabel = mock(() => ({ run: runSpam }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
+            const runAllThreadLabels = mock(async () => []);
+            const whereThreadLabel = mock(() => ({ run: runAllThreadLabels }));
+            const runMessages = mock(async () => messageRecords);
+            const whereMessages = mock(() => ({ run: runMessages }));
+            const threadLabelInsert = mock(async () => { });
+            const threadUpdate = mock(async () => { });
+            const threadByLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: mock(async () => { }),
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                    threadByLabel: {
+                        delete: mock(async () => { }),
+                        insert: threadByLabelInsert,
+                    },
+                    threadLabel: {
+                        delete: mock(async () => { }),
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                    threadMessage: {
+                        where: whereMessages,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setSpam(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
+                accountId: 'test-account-id-1',
+                labelId: 'test-spam-label-id',
+                threadId: 'test-thread-id-1',
+                threadMessageId: 'test-message-id-1',
+            }));
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+                labelIdList: ' test-spam-label-id ',
+            });
+        });
+    });
+    describe('setTrash', () => {
+        it('moves thread to trash', async () => {
+            const threadRecord = {
+                accountId: 'test-account-id-1',
+                id: 'test-thread-id-1',
+            };
+            const trashLabel = {
+                accountId: 'test-account-id-1',
+                id: 'test-trash-label-id',
+                specialUse: 'TRASH',
+            };
+            const messageRecords = [{ id: 'test-message-id-1' }];
+            const runThread = mock(async () => threadRecord);
+            const oneThread = mock(() => ({ run: runThread }));
+            const whereThread = mock(() => ({ one: oneThread }));
+            const runTrash = mock(async () => trashLabel);
+            const oneLabel = mock(() => ({ run: runTrash }));
+            const whereSpecialUse = mock(() => ({ one: oneLabel }));
+            const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
+            const runAllThreadLabels = mock(async () => []);
+            const whereThreadLabel = mock(() => ({ run: runAllThreadLabels }));
+            const runMessages = mock(async () => messageRecords);
+            const whereMessages = mock(() => ({ run: runMessages }));
+            const threadLabelInsert = mock(async () => { });
+            const threadUpdate = mock(async () => { });
+            const threadByLabelInsert = mock(async () => { });
+            const transaction = {
+                mutate: {
+                    accountLabel: {
+                        update: mock(async () => { }),
+                    },
+                    thread: {
+                        update: threadUpdate,
+                    },
+                    threadByLabel: {
+                        delete: mock(async () => { }),
+                        insert: threadByLabelInsert,
+                    },
+                    threadLabel: {
+                        delete: mock(async () => { }),
+                        insert: threadLabelInsert,
+                    },
+                },
+                query: {
+                    accountLabel: {
+                        where: whereLabelAccount,
+                    },
+                    thread: {
+                        where: whereThread,
+                    },
+                    threadLabel: {
+                        where: whereThreadLabel,
+                    },
+                    threadMessage: {
+                        where: whereMessages,
+                    },
+                },
+            };
+            const mutators = createMutators();
+            await mutators.thread.setTrash(transaction, {
+                accounts: { 'test-account-id-1': { threadIds: ['test-thread-id-1'] } },
+            });
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
+                accountId: 'test-account-id-1',
+                labelId: 'test-trash-label-id',
+                threadId: 'test-thread-id-1',
+                threadMessageId: 'test-message-id-1',
+            }));
+            expect(threadUpdate).toHaveBeenCalledWith({
+                id: 'test-thread-id-1',
+                labelIdList: ' test-trash-label-id ',
+            });
+        });
+    });
+});