435 lines
18 KiB
TypeScript
435 lines
18 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
import { buildMailboxTree, flattenMailboxTree, type MailboxNode } from '@/lib/utils';
|
|
import type { Mailbox } from '@/lib/jmap/types';
|
|
|
|
const makeMailbox = (overrides: Partial<Mailbox> = {}): Mailbox => ({
|
|
id: 'mb-1',
|
|
name: 'Test',
|
|
sortOrder: 0,
|
|
totalEmails: 0,
|
|
unreadEmails: 0,
|
|
totalThreads: 0,
|
|
unreadThreads: 0,
|
|
myRights: {
|
|
mayReadItems: true,
|
|
mayAddItems: true,
|
|
mayRemoveItems: true,
|
|
maySetSeen: true,
|
|
maySetKeywords: true,
|
|
mayCreateChild: true,
|
|
mayRename: true,
|
|
mayDelete: true,
|
|
maySubmit: true,
|
|
},
|
|
isSubscribed: true,
|
|
...overrides,
|
|
});
|
|
|
|
/**
|
|
* Helper: walk the tree and collect { id, depth, parentId } for every node.
|
|
*/
|
|
function collectNodes(tree: MailboxNode[]): { id: string; depth: number; parentName?: string }[] {
|
|
const result: { id: string; depth: number; parentName?: string }[] = [];
|
|
const walk = (nodes: MailboxNode[], parentName?: string) => {
|
|
for (const node of nodes) {
|
|
result.push({ id: node.id, depth: node.depth, parentName });
|
|
if (node.children.length > 0) walk(node.children, node.name);
|
|
}
|
|
};
|
|
walk(tree);
|
|
return result;
|
|
}
|
|
|
|
describe('mailbox deep nesting (depth 4+)', () => {
|
|
// Reproduce the exact scenario from the bug report:
|
|
// INBOX > PRIVAT > BOOKINGS > BOOKING1/BOOKING2/FLIGHTS/HOTEL1/HOTEL2/HOTEL3
|
|
// HOTEL2 > RESTAURANT (depth 4)
|
|
it('should correctly nest the reported folder structure (depth 4)', () => {
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'INBOX', role: 'inbox' }),
|
|
makeMailbox({ id: 'privat', name: 'PRIVAT', parentId: 'inbox' }),
|
|
makeMailbox({ id: 'bookings', name: 'BOOKINGS', parentId: 'privat' }),
|
|
makeMailbox({ id: 'booking1', name: 'BOOKING1', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'booking2', name: 'BOOKING2', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'flights', name: 'FLIGHTS', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'hotel1', name: 'HOTEL1', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'hotel2', name: 'HOTEL2', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'hotel3', name: 'HOTEL3', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'restaurant', name: 'RESTAURANT', parentId: 'hotel2' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const byId = Object.fromEntries(flat.map((n) => [n.id, n]));
|
|
|
|
// RESTAURANT should be at depth 4, NOT depth 0
|
|
expect(byId['restaurant'].depth).toBe(4);
|
|
// Verify the full chain of depths
|
|
expect(byId['inbox'].depth).toBe(0);
|
|
expect(byId['privat'].depth).toBe(1);
|
|
expect(byId['bookings'].depth).toBe(2);
|
|
expect(byId['hotel2'].depth).toBe(3);
|
|
expect(byId['restaurant'].depth).toBe(4);
|
|
});
|
|
|
|
it('should not orphan depth-4 folders to root level', () => {
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'INBOX', role: 'inbox' }),
|
|
makeMailbox({ id: 'privat', name: 'PRIVAT', parentId: 'inbox' }),
|
|
makeMailbox({ id: 'bookings', name: 'BOOKINGS', parentId: 'privat' }),
|
|
makeMailbox({ id: 'hotel2', name: 'HOTEL2', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'restaurant', name: 'RESTAURANT', parentId: 'hotel2' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
|
|
// RESTAURANT must NOT appear at root level
|
|
const rootNames = tree.map(n => n.name);
|
|
expect(rootNames).not.toContain('RESTAURANT');
|
|
|
|
// It must be nested under HOTEL2
|
|
const nodes = collectNodes(tree);
|
|
const restaurant = nodes.find(n => n.id === 'restaurant');
|
|
expect(restaurant).toBeDefined();
|
|
expect(restaurant!.depth).toBe(4);
|
|
expect(restaurant!.parentName).toBe('HOTEL2');
|
|
});
|
|
|
|
it('should handle nesting up to depth 6', () => {
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'l0', name: 'Level0', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l1', name: 'Level1', parentId: 'l0', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l2', name: 'Level2', parentId: 'l1', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l3', name: 'Level3', parentId: 'l2', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l4', name: 'Level4', parentId: 'l3', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l5', name: 'Level5', parentId: 'l4', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l6', name: 'Level6', parentId: 'l5', sortOrder: 0 }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const byId = Object.fromEntries(flat.map((n) => [n.id, n]));
|
|
|
|
// Only 1 root node
|
|
expect(tree).toHaveLength(1);
|
|
expect(tree[0].name).toBe('Level0');
|
|
|
|
// Verify all depths are correct
|
|
for (let i = 0; i <= 6; i++) {
|
|
expect(byId[`l${i}`].depth).toBe(i);
|
|
}
|
|
});
|
|
|
|
it('should handle nesting up to depth 10 (Stalwart default max)', () => {
|
|
const mailboxes: Mailbox[] = [];
|
|
for (let i = 0; i <= 10; i++) {
|
|
mailboxes.push(
|
|
makeMailbox({
|
|
id: `level-${i}`,
|
|
name: `Folder${i}`,
|
|
parentId: i === 0 ? undefined : `level-${i - 1}`,
|
|
sortOrder: 0,
|
|
})
|
|
);
|
|
}
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
|
|
// Should have exactly 11 nodes total
|
|
expect(flat).toHaveLength(11);
|
|
// Only 1 root
|
|
expect(tree).toHaveLength(1);
|
|
|
|
// Each node at correct depth
|
|
for (let i = 0; i <= 10; i++) {
|
|
const node = flat.find(n => n.id === `level-${i}`);
|
|
expect(node).toBeDefined();
|
|
expect(node!.depth).toBe(i);
|
|
}
|
|
});
|
|
|
|
it('should correctly count children at each level in deep trees', () => {
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'root', name: 'Root', sortOrder: 0 }),
|
|
makeMailbox({ id: 'a', name: 'A', parentId: 'root' }),
|
|
makeMailbox({ id: 'b', name: 'B', parentId: 'root' }),
|
|
makeMailbox({ id: 'a1', name: 'A1', parentId: 'a' }),
|
|
makeMailbox({ id: 'a2', name: 'A2', parentId: 'a' }),
|
|
makeMailbox({ id: 'a1x', name: 'A1X', parentId: 'a1' }),
|
|
makeMailbox({ id: 'a1y', name: 'A1Y', parentId: 'a1' }),
|
|
makeMailbox({ id: 'a1x_deep', name: 'A1X_DEEP', parentId: 'a1x' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const byId = Object.fromEntries(flat.map((n) => [n.id, n]));
|
|
|
|
// Verify structure
|
|
expect(tree).toHaveLength(1); // just Root
|
|
expect(tree[0].children).toHaveLength(2); // A, B
|
|
|
|
// Check depths
|
|
expect(byId['root'].depth).toBe(0);
|
|
expect(byId['a'].depth).toBe(1);
|
|
expect(byId['b'].depth).toBe(1);
|
|
expect(byId['a1'].depth).toBe(2);
|
|
expect(byId['a2'].depth).toBe(2);
|
|
expect(byId['a1x'].depth).toBe(3);
|
|
expect(byId['a1y'].depth).toBe(3);
|
|
expect(byId['a1x_deep'].depth).toBe(4);
|
|
});
|
|
|
|
it('should flatten deep trees in correct parent-before-child order', () => {
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'l0', name: 'L0', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l1', name: 'L1', parentId: 'l0', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l2', name: 'L2', parentId: 'l1', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l3', name: 'L3', parentId: 'l2', sortOrder: 0 }),
|
|
makeMailbox({ id: 'l4', name: 'L4', parentId: 'l3', sortOrder: 0 }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const ids = flat.map(n => n.id);
|
|
|
|
// Parent must always come before child in the flat list
|
|
for (let i = 0; i < 4; i++) {
|
|
const parentIdx = ids.indexOf(`l${i}`);
|
|
const childIdx = ids.indexOf(`l${i + 1}`);
|
|
expect(parentIdx).toBeLessThan(childIdx);
|
|
}
|
|
});
|
|
|
|
it('should handle mailboxes provided in reverse order (children before parents)', () => {
|
|
// JMAP doesn't guarantee order - children might arrive before parents
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'restaurant', name: 'RESTAURANT', parentId: 'hotel2' }),
|
|
makeMailbox({ id: 'hotel2', name: 'HOTEL2', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'bookings', name: 'BOOKINGS', parentId: 'privat' }),
|
|
makeMailbox({ id: 'privat', name: 'PRIVAT', parentId: 'inbox' }),
|
|
makeMailbox({ id: 'inbox', name: 'INBOX', role: 'inbox' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const byId = Object.fromEntries(flat.map((n) => [n.id, n]));
|
|
|
|
// All nodes present
|
|
expect(flat).toHaveLength(5);
|
|
// Only 1 root
|
|
expect(tree).toHaveLength(1);
|
|
// Correct depths regardless of input order
|
|
expect(byId['inbox'].depth).toBe(0);
|
|
expect(byId['privat'].depth).toBe(1);
|
|
expect(byId['bookings'].depth).toBe(2);
|
|
expect(byId['hotel2'].depth).toBe(3);
|
|
expect(byId['restaurant'].depth).toBe(4);
|
|
});
|
|
|
|
it('should handle wide + deep trees without orphaning', () => {
|
|
// Mix of wide (many siblings) and deep nesting
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'INBOX', role: 'inbox' }),
|
|
// 5 children of inbox
|
|
...Array.from({ length: 5 }, (_, i) =>
|
|
makeMailbox({ id: `child-${i}`, name: `Child${i}`, parentId: 'inbox' })
|
|
),
|
|
// Each child has 2 sub-children
|
|
...Array.from({ length: 5 }, (_, i) => [
|
|
makeMailbox({ id: `gc-${i}-0`, name: `GC${i}-0`, parentId: `child-${i}` }),
|
|
makeMailbox({ id: `gc-${i}-1`, name: `GC${i}-1`, parentId: `child-${i}` }),
|
|
]).flat(),
|
|
// Some grandchildren have great-grandchildren (depth 3)
|
|
makeMailbox({ id: 'ggc-0', name: 'GGC0', parentId: 'gc-0-0' }),
|
|
makeMailbox({ id: 'ggc-1', name: 'GGC1', parentId: 'gc-2-1' }),
|
|
// depth 4
|
|
makeMailbox({ id: 'gggc-0', name: 'GGGC0', parentId: 'ggc-0' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const rootNames = tree.map(n => n.name);
|
|
|
|
// Only INBOX should be at root
|
|
expect(rootNames).toEqual(['INBOX']);
|
|
// Total nodes
|
|
expect(flat).toHaveLength(mailboxes.length);
|
|
|
|
// Verify depth-4 node
|
|
const gggc = flat.find(n => n.id === 'gggc-0');
|
|
expect(gggc).toBeDefined();
|
|
expect(gggc!.depth).toBe(4);
|
|
});
|
|
});
|
|
|
|
describe('GitHub #118: duplicate subfolder names cause depth-4 orphaning', () => {
|
|
it('should keep nested folders when a subfolder has the same name as a role mailbox', () => {
|
|
// Reporter's exact scenario: two subfolders with the same name.
|
|
// The dedup uses substring matching and removes non-role folders whose name
|
|
// matches a role folder - even if they're deep in the tree with children.
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'Inbox', role: 'inbox' }),
|
|
makeMailbox({ id: 'sent-role', name: 'Sent', role: 'sent' }),
|
|
// User-created subfolder also named "Sent" nested under Inbox
|
|
makeMailbox({ id: 'sent-custom', name: 'Sent', parentId: 'inbox' }),
|
|
// Child of the custom "Sent" folder - becomes orphaned if parent is deduped
|
|
makeMailbox({ id: 'sent-child', name: 'Archive', parentId: 'sent-custom' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const rootIds = tree.map(n => n.id);
|
|
|
|
// sent-custom MUST be kept because it has children - removing it orphans sent-child
|
|
const sentCustom = flat.find(n => n.id === 'sent-custom');
|
|
expect(sentCustom).toBeDefined();
|
|
expect(sentCustom!.depth).toBe(1); // nested under Inbox
|
|
|
|
const sentChild = flat.find(n => n.id === 'sent-child');
|
|
expect(sentChild).toBeDefined();
|
|
expect(sentChild!.depth).toBe(2); // nested under sent-custom
|
|
expect(rootIds).not.toContain('sent-child'); // must NOT be orphaned at root
|
|
});
|
|
|
|
it('should keep nested folders when name is substring of a role name', () => {
|
|
// "Draft" is a substring of "Drafts" - dedup removes it, orphaning children
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'Inbox', role: 'inbox' }),
|
|
makeMailbox({ id: 'drafts-role', name: 'Drafts', role: 'drafts' }),
|
|
makeMailbox({ id: 'draft-folder', name: 'Draft', parentId: 'inbox' }),
|
|
makeMailbox({ id: 'draft-child', name: 'Notes', parentId: 'draft-folder' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const rootIds = tree.map(n => n.id);
|
|
|
|
const draftChild = flat.find(n => n.id === 'draft-child');
|
|
expect(draftChild).toBeDefined();
|
|
expect(draftChild!.depth).toBe(2);
|
|
expect(rootIds).not.toContain('draft-child');
|
|
});
|
|
|
|
it('should handle the exact reported structure with duplicate names at different depths', () => {
|
|
// Stalwart allows creating subfolders with the same name at different levels.
|
|
// If any of those names match a role mailbox name, dedup could remove them.
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'Inbox', role: 'inbox' }),
|
|
makeMailbox({ id: 'trash-role', name: 'Trash', role: 'trash' }),
|
|
makeMailbox({ id: 'privat', name: 'PRIVAT', parentId: 'inbox' }),
|
|
makeMailbox({ id: 'bookings', name: 'BOOKINGS', parentId: 'privat' }),
|
|
// User created a subfolder named "Trash" under BOOKINGS (e.g. for old bookings)
|
|
makeMailbox({ id: 'trash-custom', name: 'Trash', parentId: 'bookings' }),
|
|
// Depth 4: child of the custom Trash folder
|
|
makeMailbox({ id: 'restaurant', name: 'RESTAURANT', parentId: 'trash-custom' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const rootIds = tree.map(n => n.id);
|
|
|
|
// RESTAURANT must be at depth 4, not orphaned at root
|
|
const restaurant = flat.find(n => n.id === 'restaurant');
|
|
expect(restaurant).toBeDefined();
|
|
expect(restaurant!.depth).toBe(4);
|
|
expect(rootIds).not.toContain('restaurant');
|
|
|
|
// Custom "Trash" must be kept as it has children
|
|
const trashCustom = flat.find(n => n.id === 'trash-custom');
|
|
expect(trashCustom).toBeDefined();
|
|
expect(trashCustom!.depth).toBe(3);
|
|
});
|
|
|
|
it('should only dedup root-level non-role mailboxes that duplicate role mailboxes', () => {
|
|
// Dedup should only remove mailboxes that are BOTH:
|
|
// 1. At root level (no parentId) - same structural position as role mailbox
|
|
// 2. Name-matching a role mailbox
|
|
// Nested mailboxes with matching names should always be kept.
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'Inbox', role: 'inbox' }),
|
|
makeMailbox({ id: 'sent-role', name: 'Sent', role: 'sent' }),
|
|
makeMailbox({ id: 'sent-dup', name: 'Sent Mail' }), // root-level duplicate - OK to remove
|
|
makeMailbox({ id: 'proj', name: 'Projects', parentId: 'inbox' }),
|
|
makeMailbox({ id: 'sent-nested', name: 'Sent', parentId: 'proj' }), // nested - must keep
|
|
makeMailbox({ id: 'report', name: 'Report', parentId: 'sent-nested' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
|
|
// "Sent Mail" at root (no parentId) can be deduped - that's fine
|
|
// But "Sent" nested under Projects must be kept
|
|
const sentNested = flat.find(n => n.id === 'sent-nested');
|
|
expect(sentNested).toBeDefined();
|
|
expect(sentNested!.depth).toBe(2);
|
|
|
|
const report = flat.find(n => n.id === 'report');
|
|
expect(report).toBeDefined();
|
|
expect(report!.depth).toBe(3);
|
|
});
|
|
});
|
|
|
|
describe('mailbox orphan behavior (missing parent)', () => {
|
|
it('should expose orphan-to-root behavior when parent is missing', () => {
|
|
// Simulates what happens if JMAP response is incomplete (e.g., truncated at 500 objects)
|
|
// Middle parent "bookings" is missing from the response
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'inbox', name: 'INBOX', role: 'inbox' }),
|
|
makeMailbox({ id: 'privat', name: 'PRIVAT', parentId: 'inbox' }),
|
|
// 'bookings' is MISSING - simulating truncated JMAP response
|
|
makeMailbox({ id: 'hotel2', name: 'HOTEL2', parentId: 'bookings' }),
|
|
makeMailbox({ id: 'restaurant', name: 'RESTAURANT', parentId: 'hotel2' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const rootIds = tree.map(n => n.id);
|
|
|
|
// hotel2's parent ("bookings") is missing from the response.
|
|
// Current behavior: hotel2 becomes a root node (orphaned).
|
|
// This means RESTAURANT also appears under hotel2 at root, but at depth 1 instead of depth 4.
|
|
const hotel2 = flat.find(n => n.id === 'hotel2');
|
|
expect(hotel2).toBeDefined();
|
|
|
|
// Diagnostic: document that orphaning DOES happen
|
|
if (rootIds.includes('hotel2')) {
|
|
expect(hotel2!.depth).toBe(0); // orphaned at root
|
|
const restaurant = flat.find(n => n.id === 'restaurant');
|
|
expect(restaurant!.depth).toBe(1); // child of orphaned root
|
|
console.warn(
|
|
'CONFIRMED: Missing intermediate parent causes orphan-to-root. ' +
|
|
'hotel2 (parentId: "bookings") is at root with depth 0 instead of depth 3.'
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should expose orphan behavior with multiple missing parents in chain', () => {
|
|
// Deep chain where two intermediate parents are missing
|
|
const mailboxes = [
|
|
makeMailbox({ id: 'root', name: 'Root', sortOrder: 0 }),
|
|
// 'level1' is MISSING
|
|
// 'level2' is MISSING
|
|
makeMailbox({ id: 'level3', name: 'Level3', parentId: 'level2' }),
|
|
makeMailbox({ id: 'level4', name: 'Level4', parentId: 'level3' }),
|
|
];
|
|
|
|
const tree = buildMailboxTree(mailboxes);
|
|
const flat = flattenMailboxTree(tree);
|
|
const rootIds = tree.map(n => n.id);
|
|
|
|
// level3's parent (level2) is missing → level3 becomes root
|
|
expect(rootIds).toContain('level3');
|
|
|
|
// level4 is correctly nested under level3 (since level3 IS in the map)
|
|
const level4 = flat.find(n => n.id === 'level4');
|
|
expect(level4).toBeDefined();
|
|
expect(level4!.depth).toBe(1); // child of orphaned level3 (depth 0)
|
|
|
|
console.warn(
|
|
'CONFIRMED: Missing parents in chain cause subtree to float to root. ' +
|
|
'Level3 (expected depth 2) is at depth 0, Level4 (expected depth 3) is at depth 1.'
|
|
);
|
|
});
|
|
});
|