298 lines
11 KiB
TypeScript
298 lines
11 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import { buildRelationshipGroups, countAllByFilter, countAllNotesByFilter, countByFilter, filterEntries } from './noteListHelpers'
|
|
import { allSelection, makeEntry, mockEntries } from '../test-utils/noteListTestUtils'
|
|
|
|
describe('filterEntries', () => {
|
|
it('returns empty for entity selections because entity view uses grouped relationships', () => {
|
|
const result = filterEntries(mockEntries, { kind: 'entity', entry: mockEntries[4] })
|
|
expect(result).toHaveLength(0)
|
|
})
|
|
|
|
it('filters section groups by open sub-filter', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', title: 'Active', isA: 'Project' }),
|
|
makeEntry({ path: '/2.md', title: 'Archived', isA: 'Project', archived: true }),
|
|
makeEntry({ path: '/4.md', title: 'Other', isA: 'Note' }),
|
|
]
|
|
|
|
const result = filterEntries(entries, { kind: 'sectionGroup', type: 'Project' }, 'open')
|
|
expect(result.map((entry) => entry.title)).toEqual(['Active'])
|
|
})
|
|
|
|
it('filters section groups by archived sub-filter', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', title: 'Active', isA: 'Project' }),
|
|
makeEntry({ path: '/2.md', title: 'Archived', isA: 'Project', archived: true }),
|
|
makeEntry({ path: '/4.md', title: 'Other', isA: 'Note' }),
|
|
]
|
|
|
|
const result = filterEntries(entries, { kind: 'sectionGroup', type: 'Project' }, 'archived')
|
|
expect(result.map((entry) => entry.title)).toEqual(['Archived'])
|
|
})
|
|
|
|
it('defaults section groups to active notes when no sub-filter is provided', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', title: 'Active', isA: 'Project' }),
|
|
makeEntry({ path: '/2.md', title: 'Archived', isA: 'Project', archived: true }),
|
|
makeEntry({ path: '/4.md', title: 'Other', isA: 'Note' }),
|
|
]
|
|
|
|
const result = filterEntries(entries, { kind: 'sectionGroup', type: 'Project' })
|
|
expect(result.map((entry) => entry.title)).toEqual(['Active'])
|
|
})
|
|
|
|
it('filters all notes by open sub-filter', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', title: 'Active', isA: 'Project' }),
|
|
makeEntry({ path: '/2.md', title: 'Archived', isA: 'Project', archived: true }),
|
|
makeEntry({ path: '/4.md', title: 'Other', isA: 'Note' }),
|
|
]
|
|
|
|
const result = filterEntries(entries, allSelection, 'open')
|
|
expect(result.map((entry) => entry.title)).toEqual(['Active', 'Other'])
|
|
})
|
|
|
|
it('filters all notes by archived sub-filter', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', title: 'Active', isA: 'Project' }),
|
|
makeEntry({ path: '/2.md', title: 'Archived', isA: 'Project', archived: true }),
|
|
makeEntry({ path: '/4.md', title: 'Other', isA: 'Note' }),
|
|
]
|
|
|
|
const result = filterEntries(entries, allSelection, 'archived')
|
|
expect(result.map((entry) => entry.title)).toEqual(['Archived'])
|
|
})
|
|
|
|
it('excludes attachments-folder markdown from the All Notes view', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/vault/note/real-note.md', title: 'Real Note', isA: 'Note' }),
|
|
makeEntry({ path: '/vault/attachments/reference.md', title: 'Attachment Markdown', isA: 'Note' }),
|
|
makeEntry({ path: '/vault/attachments/nested/diagram.md', title: 'Nested Attachment Markdown', isA: 'Note' }),
|
|
makeEntry({ path: 'C:\\Users\\luca\\Vault\\attachments\\windows.md', title: 'Windows Attachment Markdown', isA: 'Note' }),
|
|
]
|
|
|
|
const result = filterEntries(entries, allSelection, 'open')
|
|
expect(result.map((entry) => entry.title)).toEqual(['Real Note'])
|
|
})
|
|
|
|
it('matches slash-based folder selections against Windows entry paths', () => {
|
|
const entries = [
|
|
makeEntry({ path: 'C:\\Users\\luca\\Vault\\Client Work\\Alpha.md', title: 'Alpha' }),
|
|
makeEntry({ path: 'C:\\Users\\luca\\Vault\\Client Work\\Nested\\Beta.md', title: 'Beta' }),
|
|
makeEntry({ path: 'C:\\Users\\luca\\Vault\\Client Work Archive\\Old.md', title: 'Archive' }),
|
|
makeEntry({ path: 'C:\\Users\\luca\\Vault\\客户\\计划.md', title: 'Unicode' }),
|
|
]
|
|
|
|
expect(filterEntries(entries, { kind: 'folder', path: 'Client Work' }).map((entry) => entry.title)).toEqual(['Alpha', 'Beta'])
|
|
expect(filterEntries(entries, { kind: 'folder', path: '客户' }).map((entry) => entry.title)).toEqual(['Unicode'])
|
|
})
|
|
|
|
it('shows only direct root-level files when selecting the vault root folder', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/Users/luca/Laputa/root-note.md', title: 'Root Note', fileKind: 'markdown' }),
|
|
makeEntry({ path: '/Users/luca/Laputa/config.json', title: 'config.json', fileKind: 'text' }),
|
|
makeEntry({ path: '/Users/luca/Laputa/projects/nested.md', title: 'Nested Note', fileKind: 'markdown' }),
|
|
makeEntry({ path: '/Users/luca/Laputa/assets/logo.png', title: 'Logo', fileKind: 'binary' }),
|
|
]
|
|
|
|
const result = filterEntries(entries, { kind: 'folder', path: '', rootPath: '/Users/luca/Laputa' })
|
|
|
|
expect(result.map((entry) => entry.title)).toEqual(['Root Note', 'config.json'])
|
|
})
|
|
})
|
|
|
|
describe('countByFilter', () => {
|
|
it('counts open and archived entries for a type', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', isA: 'Project' }),
|
|
makeEntry({ path: '/2.md', isA: 'Project', archived: true }),
|
|
makeEntry({ path: '/3.md', isA: 'Project' }),
|
|
makeEntry({ path: '/4.md', isA: 'Note' }),
|
|
]
|
|
|
|
expect(countByFilter(entries, 'Project')).toEqual({ open: 2, archived: 1 })
|
|
})
|
|
|
|
it('returns zeros when a type has no matching entries', () => {
|
|
expect(countByFilter([], 'Project')).toEqual({ open: 0, archived: 0 })
|
|
})
|
|
})
|
|
|
|
describe('countAllByFilter', () => {
|
|
it('counts all entries by archive status', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', isA: 'Project' }),
|
|
makeEntry({ path: '/2.md', isA: 'Note' }),
|
|
makeEntry({ path: '/3.md', isA: 'Project', archived: true }),
|
|
]
|
|
|
|
expect(countAllByFilter(entries)).toEqual({ open: 2, archived: 1 })
|
|
})
|
|
|
|
it('excludes non-markdown files from counts', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/1.md', isA: 'Note', fileKind: 'markdown' }),
|
|
makeEntry({ path: '/2.yml', isA: undefined, fileKind: 'text' }),
|
|
makeEntry({ path: '/3.png', isA: undefined, fileKind: 'binary' }),
|
|
]
|
|
|
|
expect(countAllByFilter(entries)).toEqual({ open: 1, archived: 0 })
|
|
})
|
|
})
|
|
|
|
describe('countAllNotesByFilter', () => {
|
|
it('excludes attachments-folder files from All Notes totals', () => {
|
|
const entries = [
|
|
makeEntry({ path: '/vault/note/real-note.md', isA: 'Note' }),
|
|
makeEntry({ path: '/vault/attachments/reference.md', isA: 'Note' }),
|
|
makeEntry({ path: '/vault/attachments/archive.md', isA: 'Note', archived: true }),
|
|
makeEntry({ path: '/vault/attachments/image.png', fileKind: 'binary' }),
|
|
makeEntry({ path: '/vault/archive/real-archive.md', isA: 'Note', archived: true }),
|
|
]
|
|
|
|
expect(countAllNotesByFilter(entries)).toEqual({ open: 1, archived: 1 })
|
|
})
|
|
})
|
|
|
|
describe('buildRelationshipGroups', () => {
|
|
it('omits computed neighborhood groups when they are absent', () => {
|
|
const standalone = makeEntry({
|
|
path: '/vault/solo.md',
|
|
filename: 'solo.md',
|
|
title: 'Standalone',
|
|
isA: 'Note',
|
|
})
|
|
|
|
const groups = buildRelationshipGroups(standalone, [standalone])
|
|
|
|
expect(groups).toEqual([])
|
|
})
|
|
|
|
it('allows the same note to appear in multiple relationship groups', () => {
|
|
const parent = makeEntry({
|
|
path: '/vault/parent.md',
|
|
filename: 'parent.md',
|
|
title: 'Parent',
|
|
isA: 'Project',
|
|
relationships: { 'Related to': ['[[shared-note]]'] },
|
|
})
|
|
const shared = makeEntry({
|
|
path: '/vault/shared-note.md',
|
|
filename: 'shared-note.md',
|
|
title: 'Shared Note',
|
|
isA: 'Note',
|
|
relatedTo: ['[[parent]]'],
|
|
})
|
|
|
|
const groups = buildRelationshipGroups(parent, [parent, shared])
|
|
|
|
expect(groups.find((group) => group.label === 'Related to')?.entries).toEqual([shared])
|
|
expect(groups.find((group) => group.label === 'Referenced by')?.entries).toEqual([shared])
|
|
})
|
|
|
|
it('normalizes canonical inverse relationship keys without duplicating raw inverse groups', () => {
|
|
const parent = makeEntry({
|
|
path: '/vault/parent.md',
|
|
filename: 'parent.md',
|
|
title: 'Parent',
|
|
isA: 'Project',
|
|
})
|
|
const child = makeEntry({
|
|
path: '/vault/child.md',
|
|
filename: 'child.md',
|
|
title: 'Child',
|
|
isA: 'Note',
|
|
belongsTo: ['[[parent]]'],
|
|
relationships: {
|
|
belongs_to: ['[[parent]]'],
|
|
},
|
|
})
|
|
const related = makeEntry({
|
|
path: '/vault/related.md',
|
|
filename: 'related.md',
|
|
title: 'Related',
|
|
isA: 'Note',
|
|
relatedTo: ['[[parent]]'],
|
|
relationships: {
|
|
related_to: ['[[parent]]'],
|
|
},
|
|
})
|
|
|
|
const groups = buildRelationshipGroups(parent, [parent, child, related])
|
|
|
|
expect(groups.find((group) => group.label === 'Children')?.entries).toEqual([child])
|
|
expect(groups.find((group) => group.label === 'Referenced by')?.entries).toEqual([related])
|
|
expect(groups.find((group) => group.label === '← belongs_to')).toBeUndefined()
|
|
expect(groups.find((group) => group.label === '← related_to')).toBeUndefined()
|
|
})
|
|
|
|
it('includes all inverse relationship groups for non-core relationship keys', () => {
|
|
const parent = makeEntry({
|
|
path: '/vault/parent.md',
|
|
filename: 'parent.md',
|
|
title: 'Parent',
|
|
isA: 'Project',
|
|
})
|
|
const topicNote = makeEntry({
|
|
path: '/vault/topic-note.md',
|
|
filename: 'topic-note.md',
|
|
title: 'Topic Note',
|
|
isA: 'Note',
|
|
relationships: { Topics: ['[[parent]]'] },
|
|
})
|
|
const mentorNote = makeEntry({
|
|
path: '/vault/mentor-note.md',
|
|
filename: 'mentor-note.md',
|
|
title: 'Mentor Note',
|
|
isA: 'Note',
|
|
relationships: { Mentors: ['[[parent]]'] },
|
|
})
|
|
const hostEvent = makeEntry({
|
|
path: '/vault/host-event.md',
|
|
filename: 'host-event.md',
|
|
title: 'Host Event',
|
|
isA: 'Event',
|
|
relationships: { Hosts: ['[[parent]]'] },
|
|
})
|
|
|
|
const groups = buildRelationshipGroups(parent, [parent, topicNote, mentorNote, hostEvent])
|
|
|
|
expect(groups.find((group) => group.label === '← Topics')?.entries).toEqual([topicNote])
|
|
expect(groups.find((group) => group.label === '← Mentors')?.entries).toEqual([mentorNote])
|
|
expect(groups.find((group) => group.label === '← Hosts')?.entries).toEqual([hostEvent])
|
|
})
|
|
|
|
it('does not treat path-qualified refs for a different note as reverse matches', () => {
|
|
const parent = makeEntry({
|
|
path: '/vault/projects/alpha.md',
|
|
filename: 'alpha.md',
|
|
title: 'Alpha',
|
|
isA: 'Project',
|
|
})
|
|
const archiveAlpha = makeEntry({
|
|
path: '/vault/archive/alpha.md',
|
|
filename: 'alpha.md',
|
|
title: 'Alpha Archive',
|
|
isA: 'Project',
|
|
})
|
|
const unrelatedChild = makeEntry({
|
|
path: '/vault/notes/child.md',
|
|
filename: 'child.md',
|
|
title: 'Child Note',
|
|
isA: 'Note',
|
|
belongsTo: ['[[archive/alpha]]'],
|
|
})
|
|
const unrelatedEvent = makeEntry({
|
|
path: '/vault/events/event.md',
|
|
filename: 'event.md',
|
|
title: 'Review',
|
|
isA: 'Event',
|
|
relatedTo: ['[[archive/alpha]]'],
|
|
})
|
|
|
|
const groups = buildRelationshipGroups(parent, [parent, archiveAlpha, unrelatedChild, unrelatedEvent])
|
|
|
|
expect(groups).toEqual([])
|
|
})
|
|
})
|