mirror of
https://github.com/larvit/adf-codec.git
synced 2026-11-12 11:48:29 +01:00
212 lines
14 KiB
TypeScript
212 lines
14 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
import vm from 'node:vm'
|
|
|
|
import type { AdfDocument, AdfNode } from './document.ts'
|
|
import type { JsonValue } from '../json-value.ts'
|
|
import { adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown } from '../index.ts'
|
|
import { adfDocumentFault, isAdfDocument, writableContent } from './document.ts'
|
|
import { largestNesting } from '../nesting.ts'
|
|
|
|
function fault(value: unknown): string {
|
|
return adfDocumentFault(value)?.message ?? 'accepted'
|
|
}
|
|
|
|
function faultCode(value: unknown): string {
|
|
return adfDocumentFault(value)?.code ?? 'accepted'
|
|
}
|
|
|
|
function nested(levels: number): JsonValue {
|
|
let value: JsonValue = 1
|
|
for (let level = 0; level < levels; level += 1) value = [value]
|
|
return value
|
|
}
|
|
|
|
function withAttribute(value: JsonValue): unknown {
|
|
return { content: [{ attrs: { a: value }, type: 'paragraph' }], type: 'doc', version: 1 }
|
|
}
|
|
|
|
test('accepts an editor-normal document', () => {
|
|
assert.equal(isAdfDocument({ content: [{ content: [{ text: 'x', type: 'text' }], type: 'paragraph' }], type: 'doc', version: 1 }), true)
|
|
assert.equal(isAdfDocument({ type: 'doc', version: 1 }), true)
|
|
assert.equal(fault({ content: [{ content: [{ text: 'x', type: 'text' }], type: 'paragraph' }], type: 'doc', version: 1 }), 'accepted')
|
|
})
|
|
|
|
test('names the check anything that is not a doc node failed', () => {
|
|
assert.equal(isAdfDocument(null), false)
|
|
assert.equal(fault(null), 'an ADF document is an object: found null')
|
|
assert.equal(fault(undefined), 'an ADF document is an object: found undefined')
|
|
assert.equal(fault([]), 'an ADF document is an object: found an array')
|
|
assert.equal(fault('doc'), 'an ADF document is an object: found "doc"')
|
|
assert.equal(fault('x'.repeat(200000)), `an ADF document is an object: found "${'x'.repeat(40)}…"`)
|
|
assert.equal(fault(function named(first: number, second: number) { return first + second }), 'an ADF document is an object: found a function')
|
|
assert.equal(fault({ fields: { description: { type: 'doc', version: 1 } } }), 'an ADF document holds content, type and version alone: found the key fields')
|
|
assert.equal(fault({ extra: 1, type: 'doc', version: 1 }), 'an ADF document holds content, type and version alone: found the key extra')
|
|
assert.equal(fault({ version: 1 }), 'an ADF document holds type "doc": found no type field')
|
|
assert.equal(fault({ type: 'document', version: 1 }), 'an ADF document holds type "doc": found "document"')
|
|
assert.equal(fault({ type: 'paragraph', version: 1 }), 'an ADF document holds type "doc": found "paragraph"')
|
|
assert.equal(fault({ type: 1, version: 1 }), 'an ADF document holds type "doc": found 1')
|
|
assert.equal(fault({ type: 'doc' }), 'an ADF document holds a version number: found no version field')
|
|
assert.equal(fault({ type: 'doc', version: '1' }), 'an ADF document holds a version number: found "1"')
|
|
assert.equal(fault({ type: 'doc', version: Number.NaN }), 'an ADF document holds a version number: found NaN')
|
|
})
|
|
|
|
test('rejects a node whose shape ProseMirror JSON cannot hold', () => {
|
|
assert.equal(fault({ content: {}, type: 'doc', version: 1 }), "an ADF document's content is an array: found an object")
|
|
assert.equal(fault({ content: [{ type: 1 }], type: 'doc', version: 1 }), "an ADF document's content holds ADF nodes: one of them is not")
|
|
assert.equal(isAdfDocument({ content: [{ type: 1 }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ text: 1, type: 'text' }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ node: 'x', type: 'paragraph' }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ content: {}, type: 'paragraph' }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ marks: [{ type: 1 }], text: 'x', type: 'text' }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ attrs: { a: Number.POSITIVE_INFINITY }, type: 'paragraph' }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ attrs: [], type: 'paragraph' }], type: 'doc', version: 1 }), false)
|
|
})
|
|
|
|
test('names the attribute nesting past the levels the parser reads one at, and still calls the value a document', () => {
|
|
const deeper = (key: string, type: string): string => `the ${key} attribute of ${type} nests deeper than the ${largestNesting} levels an attribute carries`
|
|
assert.equal(fault(withAttribute(nested(largestNesting))), 'accepted')
|
|
assert.equal(fault(withAttribute(nested(largestNesting + 1))), deeper('a', 'paragraph'))
|
|
assert.equal(faultCode(withAttribute(nested(largestNesting + 1))), 'unsupported-nesting-depth')
|
|
assert.equal(isAdfDocument(withAttribute(nested(largestNesting + 1))), true)
|
|
const marked = (levels: number): unknown => ({ content: [{ marks: [{ attrs: { a: nested(levels) }, type: 'link' }], text: 'x', type: 'text' }], type: 'doc', version: 1 })
|
|
assert.equal(fault(marked(largestNesting)), 'accepted')
|
|
assert.equal(fault(marked(largestNesting + 1)), deeper('a', 'link'))
|
|
assert.equal(isAdfDocument(marked(largestNesting + 1)), true)
|
|
})
|
|
|
|
test('accepts the JSON values an attribute may hold', () => {
|
|
assert.equal(isAdfDocument({ content: [{ attrs: { a: [1, 'x', null, true, { b: 2 }] }, type: 'paragraph' }], type: 'doc', version: 1 }), true)
|
|
assert.equal(isAdfDocument({ content: [{ attrs: { a: [() => 1] }, type: 'paragraph' }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ attrs: { a: Object.assign(Object.create(null), { b: 1 }) }, type: 'paragraph' }], type: 'doc', version: 1 }), true)
|
|
assert.equal(isAdfDocument(vm.runInNewContext("({ content: [{ attrs: { a: { b: [1] } }, type: 'paragraph' }], type: 'doc', version: 1 })")), true)
|
|
})
|
|
|
|
test('refuses an attribute value that is an object JSON does not hold', () => {
|
|
class Point { x = 1 }
|
|
for (const value of [new Date(0), new Map([['b', 1]]), new Set([1]), new Uint8Array([1, 2]), new Point(), [new Map()], { b: new Set() }]) {
|
|
assert.equal(isAdfDocument({ content: [{ attrs: { a: value }, type: 'paragraph' }], type: 'doc', version: 1 }), false, String(value))
|
|
}
|
|
assert.equal(isAdfDocument({ content: [{ attrs: new Map(), type: 'paragraph' }], type: 'doc', version: 1 }), false)
|
|
assert.equal(isAdfDocument({ content: [{ marks: [{ attrs: { href: new URL('https://x.test') }, type: 'link' }], text: 'x', type: 'text' }], type: 'doc', version: 1 }), false)
|
|
})
|
|
|
|
test("reads a node's siblings as a walk rather than as one call's arguments", () => {
|
|
const wide = { content: [{ content: Array.from({ length: 200000 }, () => ({ type: 'rule' })), type: 'blockquote' }], type: 'doc', version: 1 }
|
|
assert.equal(isAdfDocument(wide), true)
|
|
assert.equal(fault(wide), 'accepted')
|
|
})
|
|
|
|
test('refuses an object holding itself, and accepts one shared', () => {
|
|
const holdsItself = 'an ADF document is a tree: an object in it holds itself'
|
|
const paragraph: { content: unknown[]; type: string } = { content: [], type: 'paragraph' }
|
|
paragraph.content.push(paragraph)
|
|
assert.equal(fault({ content: [paragraph], type: 'doc', version: 1 }), holdsItself)
|
|
const document: { content: unknown[]; type: string; version: number } = { content: [], type: 'doc', version: 1 }
|
|
document.content.push(document)
|
|
assert.equal(fault(document), holdsItself)
|
|
const attrs: Record<string, unknown> = {}
|
|
attrs['a'] = [attrs]
|
|
assert.equal(fault({ content: [{ attrs, type: 'paragraph' }], type: 'doc', version: 1 }), holdsItself)
|
|
assert.equal(fault({ content: [{ marks: [{ attrs, type: 'link' }], text: 'x', type: 'text' }], type: 'doc', version: 1 }), holdsItself)
|
|
assert.equal(isAdfDocument({ content: [{ attrs, type: 'paragraph' }], type: 'doc', version: 1 }), false)
|
|
const bold = { type: 'strong' }
|
|
const text = { marks: [bold], text: 'x', type: 'text' }
|
|
const shared = { content: [text, text], type: 'paragraph' }
|
|
const values = { b: 1 }
|
|
assert.equal(fault({ content: [shared, shared, { attrs: { a: [values, values] }, type: 'paragraph' }], type: 'doc', version: 1 }), 'accepted')
|
|
})
|
|
|
|
test('opens every writer with the same checks: a document, version 1, and no more text than the longest output holds', () => {
|
|
const checked = (document: AdfDocument): string => {
|
|
const result = writableContent(document)
|
|
return result.ok ? JSON.stringify(result.value) ?? 'no content key' : result.error.code
|
|
}
|
|
assert.equal(checked({ type: 'doc', version: Number.NaN }), 'not-an-adf-document')
|
|
assert.equal(checked({ type: 'doc', version: 2 }), 'unsupported-document-version')
|
|
assert.equal(checked({ type: 'doc', version: 1 }), 'no content key')
|
|
assert.equal(checked({ content: [{ type: 'rule' }], type: 'doc', version: 1 }), '[{"type":"rule"}]')
|
|
const long = 'a'.repeat(2 ** 28)
|
|
const text = { content: [{ text: long, type: 'text' }, { text: long, type: 'text' }, { text: long, type: 'text' }], type: 'paragraph' }
|
|
assert.equal(checked({ content: [text], type: 'doc', version: 1 }), 'unsupported-node-shape')
|
|
})
|
|
|
|
test('refuses an inline card a link marks, wherever the document holds it and whichever call writes it', () => {
|
|
const card = { attrs: { url: 'https://example.com/roadmap' }, marks: [{ attrs: { href: 'https://example.com/' }, type: 'link' }], type: 'inlineCard' }
|
|
const paragraph = { content: [{ text: 'See ', type: 'text' }, card], type: 'paragraph' }
|
|
const holders = [
|
|
{ holder: paragraph, path: ['content', 0, 'content', 1] },
|
|
{ holder: { content: [{ content: [paragraph], type: 'listItem' }], type: 'bulletList' }, path: ['content', 0, 'content', 0, 'content', 0, 'content', 1] },
|
|
{ holder: { content: [paragraph], type: 'panel' }, path: ['content', 0, 'content', 0, 'content', 1] },
|
|
{ holder: { content: [card, { text: 'x', type: 'text' }], marks: [{ attrs: { align: 'center' }, type: 'alignment' }], type: 'paragraph' }, path: ['content', 0, 'content', 0] },
|
|
{ holder: { content: [{ content: [card], type: 'futureNode' }], type: 'futureBlock' }, path: ['content', 0, 'content', 0, 'content', 0] },
|
|
]
|
|
const writers = [adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown]
|
|
for (const { holder, path } of holders) {
|
|
for (const write of writers) {
|
|
const refused = write({ content: [holder], type: 'doc', version: 1 })
|
|
assert.equal(!refused.ok && refused.error.code, 'unsupported-node-shape')
|
|
assert.deepEqual(!refused.ok && refused.error.path, path)
|
|
assert.match(!refused.ok ? refused.error.message : '', /inlineCard.*link/)
|
|
}
|
|
}
|
|
})
|
|
|
|
test('refuses what Atlassian\'s schema gives no node, wherever the document holds it and whichever call writes it', () => {
|
|
const shapes: { message: string; node: AdfNode }[] = [
|
|
{ message: 'a panel carries no text: this one holds text', node: { text: 'x', type: 'panel' } },
|
|
{ message: 'a paragraph carries no text: this one holds text', node: { text: 'x', type: 'paragraph' } },
|
|
{ message: 'a media holds no content: this one holds some', node: { content: [{ type: 'paragraph' }], type: 'media' } },
|
|
{ message: 'a rule holds no content: this one holds some', node: { content: [{ type: 'paragraph' }], type: 'rule' } },
|
|
{ message: 'a status node holds neither content nor text: this one holds content', node: { content: [{ text: 'x', type: 'text' }], type: 'status' } },
|
|
{ message: 'a status node holds neither content nor text: this one holds text', node: { text: 'x', type: 'status' } },
|
|
{ message: 'a hardBreak node holds neither content nor text: this one holds text', node: { text: 'x', type: 'hardBreak' } },
|
|
]
|
|
for (const { message, node } of shapes) {
|
|
const holders = [
|
|
{ content: [node], type: 'doc' },
|
|
{ content: [{ content: [node], type: 'paragraph' }], type: 'doc' },
|
|
{ content: [{ content: [node], type: 'futureBlock' }], type: 'doc' },
|
|
]
|
|
const paths = [['content', 0], ['content', 0, 'content', 0], ['content', 0, 'content', 0]]
|
|
for (const [index, { content }] of holders.entries()) {
|
|
for (const write of [adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown]) {
|
|
const refused = write({ content, type: 'doc', version: 1 })
|
|
assert.deepEqual(refused.ok ? 'written' : refused.error, { code: 'unsupported-node-shape', message, path: paths[index] })
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
test('writes what the schema refusals leave to the carry', () => {
|
|
const carried: AdfNode[] = [
|
|
{ content: [], type: 'rule' },
|
|
{ content: [{ text: 'x', type: 'text' }], text: 'y', type: 'futureBlock' },
|
|
{ content: [{ content: [{ type: 'paragraph' }], type: 'text' }], type: 'paragraph' },
|
|
]
|
|
for (const node of carried) for (const write of [adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown]) assert.equal(write({ content: [node], type: 'doc', version: 1 }).ok, true)
|
|
})
|
|
|
|
test('names the first link-marked card in document order', () => {
|
|
const card = (url: string): AdfNode => ({ attrs: { url }, marks: [{ attrs: { href: 'https://example.com/' }, type: 'link' }], type: 'inlineCard' })
|
|
const content = [{ content: [card('https://a.example/'), card('https://b.example/')], type: 'paragraph' }, { content: [card('https://c.example/')], type: 'paragraph' }]
|
|
const refused = writableContent({ content, type: 'doc', version: 1 })
|
|
assert.deepEqual(!refused.ok && refused.error.path, ['content', 0, 'content', 0])
|
|
})
|
|
|
|
test('writes a card holding no link mark, and a node type it does not know holding one', () => {
|
|
const comment = { attrs: { annotationType: 'inlineComment', id: 'c1' }, type: 'annotation' }
|
|
const link = { attrs: { href: 'https://example.com/' }, type: 'link' }
|
|
const marked = { content: [{ attrs: { url: 'https://example.com/roadmap' }, marks: [comment], type: 'inlineCard' }, { marks: [link], type: 'futureInline' }], type: 'paragraph' }
|
|
for (const write of [adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown]) assert.equal(write({ content: [marked], type: 'doc', version: 1 }).ok, true)
|
|
})
|
|
|
|
test('names a link-marked card at any depth by its path alone, with no step quadratic in the depth', () => {
|
|
const depth = 100_000
|
|
let node: AdfNode = { attrs: { url: 'https://example.com/' }, marks: [{ attrs: { href: 'https://example.com/' }, type: 'link' }], type: 'inlineCard' }
|
|
for (let level = 0; level < depth; level += 1) node = { content: [node], type: 'panel' }
|
|
const refused = writableContent({ content: [node], type: 'doc', version: 1 })
|
|
assert.equal(!refused.ok && refused.error.path.length, 2 * (depth + 1))
|
|
assert.deepEqual(!refused.ok && refused.error.path.slice(0, 4), ['content', 0, 'content', 0])
|
|
})
|