@marcoappio/marco-config 2.0.508 → 2.0.509

package/dist/zero/mutators.test.js

@@ -0,0 +1,603 @@
+import { beforeEach, describe, expect, it, mock } from 'bun:test';
+import { MutationError } from '../types';
+import { mutators } from './mutators';
+const createMockTx = () => ({
+    mutate: {
+        account: {
+            delete: mock(() => Promise.resolve()),
+            insert: mock(() => Promise.resolve()),
+            update: mock(() => Promise.resolve()),
+        },
+        accountAlias: {
+            delete: mock(() => Promise.resolve()),
+            insert: mock(() => Promise.resolve()),
+            update: mock(() => Promise.resolve()),
+        },
+        accountLabel: { update: mock(() => Promise.resolve()) },
+        draft: {
+            delete: mock(() => Promise.resolve()),
+            insert: mock(() => Promise.resolve()),
+            update: mock(() => Promise.resolve()),
+        },
+        draftAttachment: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
+        thread: { delete: mock(() => Promise.resolve()), update: mock(() => Promise.resolve()) },
+        threadByLabel: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
+        threadLabel: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
+        user: { update: mock(() => Promise.resolve()) },
+        userPushNotificationToken: { delete: mock(() => Promise.resolve()), insert: mock(() => Promise.resolve()) },
+    },
+    run: mock(() => Promise.resolve(null)),
+});
+describe('mutators', () => {
+    let tx;
+    const ctx = { userId: 'test-user-id' };
+    beforeEach(() => {
+        tx = createMockTx();
+    });
+    describe('account', () => {
+        describe('createAccount', () => {
+            it('creates an account and primary alias', async () => {
+                const args = {
+                    aliasId: 'alias-1',
+                    color: '#ff0000',
+                    emailAddress: 'test@example.com',
+                    id: 'account-1',
+                };
+                await mutators.account.createAccount.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.account.insert).toHaveBeenCalledWith({
+                    color: '#ff0000',
+                    displayName: null,
+                    id: 'account-1',
+                    imapConnectionStatus: 'AWAITING_CONNECTION',
+                    mailProcessedCount: 0,
+                    mailTotalCount: 0,
+                    primaryAliasId: 'alias-1',
+                    userId: 'test-user-id',
+                });
+                expect(tx.mutate.accountAlias.insert).toHaveBeenCalledWith({
+                    accountId: 'account-1',
+                    emailAddress: 'test@example.com',
+                    id: 'alias-1',
+                    isPrimary: true,
+                    name: null,
+                });
+            });
+        });
+        describe('createAlias', () => {
+            it('creates a non-primary alias', async () => {
+                const args = {
+                    accountId: 'account-1',
+                    alias: {
+                        emailAddress: 'alias@example.com',
+                        id: 'alias-2',
+                        name: 'My Alias',
+                    },
+                };
+                await mutators.account.createAlias.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountAlias.insert).toHaveBeenCalledWith({
+                    accountId: 'account-1',
+                    emailAddress: 'alias@example.com',
+                    id: 'alias-2',
+                    isPrimary: false,
+                    name: 'My Alias',
+                });
+            });
+            it('creates an alias with null name', async () => {
+                const args = {
+                    accountId: 'account-1',
+                    alias: {
+                        emailAddress: 'alias@example.com',
+                        id: 'alias-2',
+                        name: null,
+                    },
+                };
+                await mutators.account.createAlias.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountAlias.insert).toHaveBeenCalledWith({
+                    accountId: 'account-1',
+                    emailAddress: 'alias@example.com',
+                    id: 'alias-2',
+                    isPrimary: false,
+                    name: null,
+                });
+            });
+        });
+        describe('deleteAccount', () => {
+            it('deletes an account', async () => {
+                const args = { id: 'account-1' };
+                await mutators.account.deleteAccount.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.account.delete).toHaveBeenCalledWith({ id: 'account-1' });
+            });
+        });
+        describe('deleteAlias', () => {
+            it('deletes a non-primary alias', async () => {
+                tx.run = mock(() => Promise.resolve({ isPrimary: false }));
+                const args = { accountId: 'account-1', aliasId: 'alias-2' };
+                await mutators.account.deleteAlias.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountAlias.delete).toHaveBeenCalledWith({ id: 'alias-2' });
+                expect(tx.mutate.accountAlias.update).not.toHaveBeenCalled();
+            });
+            it('promotes another alias when deleting primary', async () => {
+                tx.run = mock()
+                    .mockResolvedValueOnce({ isPrimary: true })
+                    .mockResolvedValueOnce([{ id: 'alias-3' }]);
+                const args = { accountId: 'account-1', aliasId: 'alias-1' };
+                await mutators.account.deleteAlias.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountAlias.delete).toHaveBeenCalledWith({ id: 'alias-1' });
+                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({ id: 'alias-3', isPrimary: true });
+                expect(tx.mutate.account.update).toHaveBeenCalledWith({ id: 'account-1', primaryAliasId: 'alias-3' });
+            });
+            it('sets primaryAliasId to null when no remaining aliases', async () => {
+                tx.run = mock().mockResolvedValueOnce({ isPrimary: true }).mockResolvedValueOnce([]);
+                const args = { accountId: 'account-1', aliasId: 'alias-1' };
+                await mutators.account.deleteAlias.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.account.update).toHaveBeenCalledWith({ id: 'account-1', primaryAliasId: null });
+            });
+        });
+        describe('setAliasName', () => {
+            it('updates alias name', async () => {
+                const args = { accountId: 'account-1', aliasId: 'alias-1', displayName: 'New Name' };
+                await mutators.account.setAliasName.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({ id: 'alias-1', name: 'New Name' });
+            });
+        });
+        describe('setAliasPrimary', () => {
+            it('sets a new primary alias', async () => {
+                tx.run = mock(() => Promise.resolve([{ id: 'alias-1' }, { id: 'alias-2' }]));
+                const args = { accountId: 'account-1', aliasId: 'alias-2' };
+                await mutators.account.setAliasPrimary.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({ id: 'alias-1', isPrimary: false });
+                expect(tx.mutate.accountAlias.update).toHaveBeenCalledWith({ id: 'alias-2', isPrimary: true });
+                expect(tx.mutate.account.update).toHaveBeenCalledWith({ id: 'account-1', primaryAliasId: 'alias-2' });
+            });
+        });
+        describe('setConnectionConfigImapRaw', () => {
+            it('updates connection status to awaiting', async () => {
+                const args = {
+                    connectionConfig: {
+                        imapHost: 'imap.example.com',
+                        imapPassword: 'pass',
+                        imapPort: 993,
+                        imapSocketType: 'SSL',
+                        imapUser: 'user',
+                        smtpHost: 'smtp.example.com',
+                        smtpPassword: 'pass',
+                        smtpPort: 465,
+                        smtpSocketType: 'SSL',
+                        smtpUser: 'user',
+                    },
+                    id: 'account-1',
+                };
+                await mutators.account.setConnectionConfigImapRaw.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.account.update).toHaveBeenCalledWith({
+                    id: 'account-1',
+                    imapConnectionStatus: 'AWAITING_CONNECTION',
+                });
+            });
+        });
+        describe('setConnectionConfigOauth', () => {
+            it('updates connection status for oauth', async () => {
+                const args = {
+                    connectionConfig: { code: 'auth-code', provider: 'GOOGLE', user: 'user@example.com' },
+                    id: 'account-1',
+                };
+                await mutators.account.setConnectionConfigOauth.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.account.update).toHaveBeenCalledWith({
+                    id: 'account-1',
+                    imapConnectionStatus: 'AWAITING_CONNECTION',
+                });
+            });
+        });
+        describe('setSettings', () => {
+            it('updates account settings', async () => {
+                const args = { color: '#00ff00', displayName: 'Work', id: 'account-1' };
+                await mutators.account.setSettings.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.account.update).toHaveBeenCalledWith({
+                    color: '#00ff00',
+                    displayName: 'Work',
+                    id: 'account-1',
+                });
+            });
+        });
+    });
+    describe('draft', () => {
+        describe('cancelSend', () => {
+            it('cancels a scheduled send', async () => {
+                tx.run = mock(() => Promise.resolve({ status: 'SEND_REQUESTED' }));
+                const args = { id: 'draft-1', updatedAt: 1234567890 };
+                await mutators.draft.cancelSend.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
+                    id: 'draft-1',
+                    scheduledFor: null,
+                    status: 'DRAFT',
+                    updatedAt: 1234567890,
+                });
+            });
+            it('throws if draft not found', async () => {
+                tx.run = mock(() => Promise.resolve(null));
+                const args = { id: 'draft-1', updatedAt: 1234567890 };
+                await expect(mutators.draft.cancelSend.fn({ args, ctx, tx: tx })).rejects.toThrow(MutationError.ENTITY_NOT_FOUND);
+            });
+            it('throws if already confirmed', async () => {
+                tx.run = mock(() => Promise.resolve({ status: 'SEND_CONFIRMED' }));
+                const args = { id: 'draft-1', updatedAt: 1234567890 };
+                await expect(mutators.draft.cancelSend.fn({ args, ctx, tx: tx })).rejects.toThrow(MutationError.ALREADY_APPLIED);
+            });
+        });
+        describe('createAttachment', () => {
+            it('creates an attachment and updates draft', async () => {
+                const args = {
+                    attachment: {
+                        fileName: 'file.pdf',
+                        id: 'attachment-1',
+                        mimeType: 'application/pdf',
+                        status: 'PENDING',
+                        totalSize: 1024,
+                    },
+                    id: 'draft-1',
+                    updatedAt: 1234567890,
+                };
+                await mutators.draft.createAttachment.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draftAttachment.insert).toHaveBeenCalledWith({
+                    draftId: 'draft-1',
+                    fileName: 'file.pdf',
+                    id: 'attachment-1',
+                    mimeType: 'application/pdf',
+                    status: 'PENDING',
+                    totalSize: 1024,
+                });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
+                    id: 'draft-1',
+                    updatedAt: 1234567890,
+                });
+            });
+        });
+        describe('createDraft', () => {
+            it('creates a draft with attachments', async () => {
+                const args = {
+                    accountId: 'account-1',
+                    attachments: [
+                        {
+                            fileName: 'file.pdf',
+                            id: 'att-1',
+                            mimeType: 'application/pdf',
+                            status: 'COMPLETE',
+                            totalSize: 1024,
+                        },
+                    ],
+                    body: { bcc: [], cc: ['cc@example.com'], content: 'Hello', subject: 'Test', to: ['to@example.com'] },
+                    error: null,
+                    from: 'from@example.com',
+                    fromName: 'Sender',
+                    id: 'draft-1',
+                    referencedMessageId: null,
+                    scheduledFor: null,
+                    status: 'DRAFT',
+                    type: 'NEW',
+                    updatedAt: 1234567890,
+                };
+                await mutators.draft.createDraft.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.insert).toHaveBeenCalledWith({
+                    accountId: 'account-1',
+                    body: { bcc: [], cc: ['cc@example.com'], content: 'Hello', to: ['to@example.com'] },
+                    error: null,
+                    fromAliasId: null,
+                    fromEmail: 'from@example.com',
+                    fromName: 'Sender',
+                    id: 'draft-1',
+                    referencedMessageId: null,
+                    scheduledFor: null,
+                    status: 'DRAFT',
+                    subject: 'Test',
+                    type: 'NEW',
+                    updatedAt: 1234567890,
+                    userId: 'test-user-id',
+                });
+                expect(tx.mutate.draftAttachment.insert).toHaveBeenCalledWith({
+                    draftId: 'draft-1',
+                    fileName: 'file.pdf',
+                    id: 'att-1',
+                    mimeType: 'application/pdf',
+                    status: 'COMPLETE',
+                    totalSize: 1024,
+                });
+            });
+        });
+        describe('deleteAttachment', () => {
+            it('deletes an attachment and updates draft', async () => {
+                const args = { attachmentId: 'att-1', id: 'draft-1', updatedAt: 1234567890 };
+                await mutators.draft.deleteAttachment.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draftAttachment.delete).toHaveBeenCalledWith({ id: 'att-1' });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({ id: 'draft-1', updatedAt: 1234567890 });
+            });
+        });
+        describe('deleteDraft', () => {
+            it('deletes a draft', async () => {
+                const args = { id: 'draft-1' };
+                await mutators.draft.deleteDraft.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.delete).toHaveBeenCalledWith({ id: 'draft-1' });
+            });
+        });
+        describe('scheduleSend', () => {
+            it('schedules an immediate send with undo delay', async () => {
+                const args = { id: 'draft-1', kind: 'IMMEDIATE', undoMs: 5000, updatedAt: 1000000 };
+                await mutators.draft.scheduleSend.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
+                    id: 'draft-1',
+                    scheduledFor: 1005000,
+                    status: 'SEND_REQUESTED',
+                    updatedAt: 1000000,
+                });
+            });
+            it('schedules a future send', async () => {
+                const args = { id: 'draft-1', kind: 'SCHEDULED', scheduledFor: 2000000, updatedAt: 1000000 };
+                await mutators.draft.scheduleSend.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
+                    id: 'draft-1',
+                    scheduledFor: 2000000,
+                    status: 'SEND_REQUESTED',
+                    updatedAt: 1000000,
+                });
+            });
+        });
+        describe('setContent', () => {
+            it('applies a content patch', async () => {
+                tx.run = mock(() => Promise.resolve({ body: { bcc: [], cc: [], content: 'Hello', to: [] } }));
+                const args = {
+                    id: 'draft-1',
+                    patch: [{ index: 5, type: 'INSERTION', value: ' World' }],
+                    updatedAt: 1234567890,
+                };
+                await mutators.draft.setContent.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
+                    body: { bcc: [], cc: [], content: 'Hello World', to: [] },
+                    id: 'draft-1',
+                    updatedAt: 1234567890,
+                });
+            });
+            it('throws if draft not found', async () => {
+                tx.run = mock(() => Promise.resolve(null));
+                const args = { id: 'draft-1', patch: [], updatedAt: 1234567890 };
+                await expect(mutators.draft.setContent.fn({ args, ctx, tx: tx })).rejects.toThrow(MutationError.ENTITY_NOT_FOUND);
+            });
+        });
+        describe('setEnvelope', () => {
+            it('updates envelope fields', async () => {
+                tx.run = mock(() => Promise.resolve({ body: { content: 'Hello' } }));
+                const args = {
+                    envelope: { bcc: ['bcc@example.com'], cc: [], subject: 'New Subject', to: ['to@example.com'] },
+                    id: 'draft-1',
+                    updatedAt: 1234567890,
+                };
+                await mutators.draft.setEnvelope.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
+                    body: { bcc: ['bcc@example.com'], cc: [], content: 'Hello', to: ['to@example.com'] },
+                    id: 'draft-1',
+                    subject: 'New Subject',
+                    updatedAt: 1234567890,
+                });
+            });
+        });
+        describe('setFrom', () => {
+            it('updates from fields', async () => {
+                const args = {
+                    accountId: 'account-2',
+                    aliasId: 'alias-2',
+                    from: 'new@example.com',
+                    fromName: 'New Name',
+                    id: 'draft-1',
+                    updatedAt: 1234567890,
+                };
+                await mutators.draft.setFrom.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.draft.update).toHaveBeenCalledWith({
+                    accountId: 'account-2',
+                    fromAliasId: 'alias-2',
+                    fromEmail: 'new@example.com',
+                    fromName: 'New Name',
+                    id: 'draft-1',
+                    updatedAt: 1234567890,
+                });
+            });
+        });
+    });
+    describe('thread', () => {
+        describe('addLabel', () => {
+            it('adds a label to threads', async () => {
+                tx.run = mock()
+                    .mockResolvedValueOnce({ id: 'label-1', uidValidity: 1, unreadCount: 0 })
+                    .mockResolvedValueOnce({
+                    id: 'thread-1',
+                    labelIdList: ' label-2 ',
+                    latestMessageDate: 1234567890,
+                    seen: true,
+                })
+                    .mockResolvedValueOnce([{ id: 'message-1' }])
+                    .mockResolvedValueOnce(null);
+                const args = {
+                    accounts: { 'account-1': { threadIds: ['thread-1'] } },
+                    labelPath: 'INBOX',
+                };
+                await mutators.thread.addLabel.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.threadByLabel.insert).toHaveBeenCalledWith({
+                    labelId: 'label-1',
+                    latestMessageDate: 1234567890,
+                    threadId: 'thread-1',
+                });
+                expect(tx.mutate.threadLabel.insert).toHaveBeenCalled();
+                expect(tx.mutate.thread.update).toHaveBeenCalledWith({
+                    id: 'thread-1',
+                    labelIdList: expect.stringContaining('label-1'),
+                });
+            });
+            it('throws if label not found', async () => {
+                tx.run = mock(() => Promise.resolve(null));
+                const args = {
+                    accounts: { 'account-1': { threadIds: ['thread-1'] } },
+                    labelPath: 'NONEXISTENT',
+                };
+                await expect(mutators.thread.addLabel.fn({ args, ctx, tx: tx })).rejects.toThrow(MutationError.ENTITY_NOT_FOUND);
+            });
+        });
+        describe('delete', () => {
+            it('deletes threads and updates unread counts', async () => {
+                tx.run = mock()
+                    .mockResolvedValueOnce({ id: 'thread-1', labelIdList: ' label-1 ', seen: false })
+                    .mockResolvedValueOnce([{ id: 'label-1', unreadCount: 5 }]);
+                const args = { accounts: { 'account-1': { threadIds: ['thread-1'] } } };
+                await mutators.thread.delete.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'label-1', unreadCount: 4 });
+                expect(tx.mutate.thread.delete).toHaveBeenCalledWith({ id: 'thread-1' });
+            });
+            it('skips unread count update for seen threads', async () => {
+                tx.run = mock(() => Promise.resolve({ id: 'thread-1', labelIdList: '', seen: true }));
+                const args = { accounts: { 'account-1': { threadIds: ['thread-1'] } } };
+                await mutators.thread.delete.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountLabel.update).not.toHaveBeenCalled();
+                expect(tx.mutate.thread.delete).toHaveBeenCalledWith({ id: 'thread-1' });
+            });
+        });
+        describe('removeLabel', () => {
+            it('removes a label from threads', async () => {
+                tx.run = mock()
+                    .mockResolvedValueOnce({ id: 'label-1', unreadCount: 5 })
+                    .mockResolvedValueOnce({ id: 'thread-1', labelIdList: ' label-1 label-2 ', seen: false })
+                    .mockResolvedValueOnce([{ id: 'message-1' }]);
+                const args = {
+                    accounts: { 'account-1': { threadIds: ['thread-1'] } },
+                    labelPath: 'INBOX',
+                };
+                await mutators.thread.removeLabel.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.threadLabel.delete).toHaveBeenCalledWith({
+                    accountId: 'account-1',
+                    labelId: 'label-1',
+                    threadMessageId: 'message-1',
+                });
+                expect(tx.mutate.threadByLabel.delete).toHaveBeenCalledWith({
+                    labelId: 'label-1',
+                    threadId: 'thread-1',
+                });
+                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'label-1', unreadCount: 4 });
+            });
+            it('throws if thread does not have label', async () => {
+                tx.run = mock()
+                    .mockResolvedValueOnce({ id: 'label-1' })
+                    .mockResolvedValueOnce({ id: 'thread-1', labelIdList: ' label-2 ' })
+                    .mockResolvedValueOnce([]);
+                const args = {
+                    accounts: { 'account-1': { threadIds: ['thread-1'] } },
+                    labelPath: 'INBOX',
+                };
+                await expect(mutators.thread.removeLabel.fn({ args, ctx, tx: tx })).rejects.toThrow(MutationError.ENTITY_NOT_FOUND);
+            });
+        });
+        describe('setFlagged', () => {
+            it('sets flagged status', async () => {
+                const args = { accounts: { 'account-1': { threadIds: ['thread-1', 'thread-2'] } }, flagged: true };
+                await mutators.thread.setFlagged.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ flagged: true, id: 'thread-1' });
+                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ flagged: true, id: 'thread-2' });
+            });
+        });
+        describe('setSeen', () => {
+            it('marks threads as seen and updates label counts', async () => {
+                tx.run = mock()
+                    .mockResolvedValueOnce([{ id: 'thread-1', labelIdList: ' label-1 ', seen: false }])
+                    .mockResolvedValueOnce([{ id: 'label-1', unreadCount: 5 }]);
+                const args = { accounts: { 'account-1': { threadIds: ['thread-1'] } }, seen: true };
+                await mutators.thread.setSeen.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'label-1', unreadCount: 4 });
+                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ id: 'thread-1', seen: true });
+            });
+            it('marks threads as unseen and increments label counts', async () => {
+                tx.run = mock()
+                    .mockResolvedValueOnce([{ id: 'thread-1', labelIdList: ' label-1 ', seen: true }])
+                    .mockResolvedValueOnce([{ id: 'label-1', unreadCount: 5 }]);
+                const args = { accounts: { 'account-1': { threadIds: ['thread-1'] } }, seen: false };
+                await mutators.thread.setSeen.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountLabel.update).toHaveBeenCalledWith({ id: 'label-1', unreadCount: 6 });
+                expect(tx.mutate.thread.update).toHaveBeenCalledWith({ id: 'thread-1', seen: false });
+            });
+            it('skips label update when thread seen status unchanged', async () => {
+                tx.run = mock(() => Promise.resolve([{ id: 'thread-1', labelIdList: ' label-1 ', seen: true }]));
+                const args = { accounts: { 'account-1': { threadIds: ['thread-1'] } }, seen: true };
+                await mutators.thread.setSeen.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.accountLabel.update).not.toHaveBeenCalled();
+            });
+        });
+        const systemLabelTestCases = [
+            { mutatorName: 'setArchive', specialUse: 'ARCHIVE' },
+            { mutatorName: 'setInbox', specialUse: 'INBOX' },
+            { mutatorName: 'setSpam', specialUse: 'SPAM' },
+            { mutatorName: 'setTrash', specialUse: 'TRASH' },
+        ];
+        for (const { mutatorName, specialUse } of systemLabelTestCases) {
+            describe(mutatorName, () => {
+                it(`moves thread to ${specialUse} label`, async () => {
+                    tx.run = mock()
+                        .mockResolvedValueOnce({
+                        accountId: 'account-1',
+                        id: 'thread-1',
+                        labelIdList: ' old-label ',
+                        latestMessageDate: 1234567890,
+                        seen: true,
+                    })
+                        .mockResolvedValueOnce({ id: 'new-label', uidValidity: 1 })
+                        .mockResolvedValueOnce([{ id: 'message-1' }])
+                        .mockResolvedValueOnce([{ id: 'old-label', unreadCount: 0 }]);
+                    const args = { accounts: { 'account-1': { threadIds: ['thread-1'] } } };
+                    await mutators.thread[mutatorName].fn({ args, ctx, tx: tx });
+                    expect(tx.mutate.threadByLabel.delete).toHaveBeenCalledWith({ labelId: 'old-label', threadId: 'thread-1' });
+                    expect(tx.mutate.threadByLabel.insert).toHaveBeenCalledWith({
+                        labelId: 'new-label',
+                        latestMessageDate: 1234567890,
+                        threadId: 'thread-1',
+                    });
+                    expect(tx.mutate.thread.update).toHaveBeenCalledWith({
+                        id: 'thread-1',
+                        labelIdList: expect.stringContaining('new-label'),
+                    });
+                });
+            });
+        }
+    });
+    describe('user', () => {
+        describe('deleteSettingsPushNotificationToken', () => {
+            it('deletes a push notification token', async () => {
+                const args = { id: 'token-1', token: 'abc123' };
+                await mutators.user.deleteSettingsPushNotificationToken.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.userPushNotificationToken.delete).toHaveBeenCalledWith({ id: 'token-1' });
+            });
+        });
+        describe('setSettingsName', () => {
+            it('updates user name', async () => {
+                const args = { id: 'user-1', name: 'New Name' };
+                await mutators.user.setSettingsName.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.user.update).toHaveBeenCalledWith({ id: 'user-1', name: 'New Name' });
+            });
+        });
+        describe('setSettingsPushNotificationToken', () => {
+            it('inserts a new push notification token', async () => {
+                tx.run = mock(() => Promise.resolve(null));
+                const args = {
+                    id: 'user-1',
+                    pushNotificationToken: { createdAt: 1234567890, id: 'token-1', token: 'abc123' },
+                };
+                await mutators.user.setSettingsPushNotificationToken.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.userPushNotificationToken.insert).toHaveBeenCalledWith({
+                    createdAt: 1234567890,
+                    id: 'token-1',
+                    token: 'abc123',
+                    userId: 'user-1',
+                });
+            });
+            it('skips insert if token already exists', async () => {
+                tx.run = mock(() => Promise.resolve({ id: 'existing-token' }));
+                const args = {
+                    id: 'user-1',
+                    pushNotificationToken: { createdAt: 1234567890, id: 'token-1', token: 'abc123' },
+                };
+                await mutators.user.setSettingsPushNotificationToken.fn({ args, ctx, tx: tx });
+                expect(tx.mutate.userPushNotificationToken.insert).not.toHaveBeenCalled();
+            });
+        });
+    });
+});