@atlaskit/adf-schema 28.1.6 → 28.1.7

package/src/__tests__/unit/schema/nodes/decision-item.ts

@@ -0,0 +1,46 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { toHTML, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+const schema = makeSchema();
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema decisionItem node`, () => {
+  it('serializes to <li> with proper data-attributes', () => {
+    const html = toHTML(schema.nodes.decisionItem.create(), schema);
+    expect(html).toContain('<li');
+    expect(html).toContain('data-decision-local-id');
+    expect(html).toContain('data-decision-state');
+  });
+
+  it('matches <li data-decision-local-id>', () => {
+    const doc = fromHTML('<li  data-decision-local-id>', schema);
+    const decisionItem = doc.firstChild!.firstChild!;
+    expect(decisionItem.type.name).toEqual('decisionItem');
+  });
+
+  it('does not match <li>', () => {
+    const doc = fromHTML('<li>', schema);
+    const listItem = doc.firstChild!.firstChild!;
+    expect(listItem.type.name).toEqual('listItem');
+  });
+
+  it('decisionItem requires defining to be true', () => {
+    expect(schema.nodes.decisionItem.spec.defining).toBe(true);
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: [
+      'doc',
+      'paragraph',
+      'heading',
+      'text',
+      'decisionList',
+      'decisionItem',
+      'orderedList',
+      'bulletList',
+      'listItem',
+    ],
+  });
+}

package/src/__tests__/unit/schema/nodes/decision-list.ts

@@ -0,0 +1,52 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { toHTML, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+const schema = makeSchema();
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema decisionList node`, () => {
+  it('serializes to <ol> with proper data-attributes', () => {
+    const html = toHTML(
+      schema.nodes.decisionList.create({ localId: 'cheese' }),
+      schema,
+    );
+    expect(html).toContain('<ol');
+    expect(html).toContain('data-decision-list-local-id="cheese"');
+  });
+
+  it('matches <ol data-decision-list-local-id>', () => {
+    const doc = fromHTML(
+      '<ol data-node-type="decisionList" data-decision-list-local-id>',
+      schema,
+    );
+    const decisionList = doc.firstChild!;
+    expect(decisionList.type.name).toEqual('decisionList');
+    expect(decisionList.attrs.localId).not.toEqual(undefined);
+  });
+
+  it('does not match <ol>', () => {
+    const doc = fromHTML('<ol>', schema);
+    const orderedList = doc.firstChild!;
+    expect(orderedList.type.name).toEqual('orderedList');
+  });
+
+  it('decisionList requires defining to be true', () => {
+    expect(schema.nodes.decisionList.spec.defining).toBe(true);
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: [
+      'doc',
+      'paragraph',
+      'heading',
+      'text',
+      'decisionList',
+      'decisionItem',
+      'orderedList',
+      'bulletList',
+      'listItem',
+    ],
+  });
+}

package/src/__tests__/unit/schema/nodes/embed-card.ts

@@ -0,0 +1,60 @@
+import { toDOM, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+import { createSchema } from '../../../../schema/create-schema';
+import { embedCard } from '../../../../schema/nodes/embed-card';
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema embedCard node`, () => {
+  const schema = createSchema({
+    nodes: ['doc', 'paragraph', 'embedCard', 'text'],
+  });
+
+  const url = 'https://product-fabric.atlassian.net/browse/ED-1';
+
+  describe('embedCard with "url" attribute', () => {
+    describe('parse html', () => {
+      it('converts to embedCard PM node', () => {
+        const doc = fromHTML(
+          `<meta charset='utf-8'><div data-embed-card="" data-card-url="https://product-fabric.atlassian.net/browse/ED-1" data-layout="center"></div>`,
+          schema,
+        );
+        const node = doc.firstChild!;
+        expect(node.type.spec).toEqual(embedCard);
+      });
+
+      it('gets attributes from html', () => {
+        const doc = fromHTML(
+          `<meta charset='utf-8'><div data-embed-card="" data-card-url="https://product-fabric.atlassian.net/browse/ED-1" data-layout="center"></div>`,
+          schema,
+        );
+
+        const node = doc.firstChild!;
+        expect(node.attrs.url).toEqual(url);
+      });
+    });
+
+    describe('encode html', () => {
+      it('converts html data attributes to node attributes', () => {
+        const dom = toDOM(
+          schema.nodes.embedCard.create({ url, layout: 'center', width: 50 }),
+          schema,
+        ).firstChild as HTMLElement;
+
+        expect(dom.getAttribute('data-card-url')).toEqual(url);
+        expect(dom.getAttribute('data-layout')).toEqual('center');
+        expect(dom.getAttribute('data-width')).toEqual('50');
+      });
+
+      it('encodes and decodes to the same node', () => {
+        const node = schema.nodes.embedCard.create({
+          url,
+          layout: 'center',
+          width: 50,
+        });
+        const dom = toDOM(node, schema).firstChild as HTMLElement;
+        const parsedNode = fromHTML(dom.outerHTML, schema).firstChild!;
+        expect(parsedNode).toEqual(node);
+      });
+    });
+  });
+});

package/src/__tests__/unit/schema/nodes/emoji.ts

@@ -0,0 +1,71 @@
+import { createSchema } from '../../../../schema/create-schema';
+import {
+  fromHTML as fromHTML_,
+  toHTML,
+} from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+const schema = makeSchema();
+const fromHTML = (html: string) => fromHTML_(html, schema);
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema underline emoji node`, () => {
+  it('should have all emoji node props when serializing to DOM', () => {
+    const html = toHTML(
+      schema.nodes.emoji.create({ shortName: 'abc', id: '123', text: 'xyz' }),
+      schema,
+    );
+    expect(html).toContain('data-emoji-short-name="abc"');
+    expect(html).toContain('data-emoji-id="123"');
+    expect(html).toContain('data-emoji-text="xyz"');
+    expect(html).toContain('contenteditable="false"');
+  });
+
+  it('should extract the correct values of emoji id', () => {
+    const doc = fromHTML(
+      '<span data-emoji-short-name="abc" data-emoji-id="123" data-emoji-text="xyz"></span>',
+    );
+    const emoji = doc.firstChild!.firstChild!;
+
+    expect(emoji.type.name).toEqual('emoji');
+    expect(emoji.attrs.shortName).toEqual('abc');
+    expect(emoji.attrs.id).toEqual('123');
+    expect(emoji.attrs.text).toEqual('xyz');
+  });
+
+  it('should have minimal emoji id props when serializing to DOM (minimal representation)', () => {
+    const html = toHTML(
+      schema.nodes.emoji.create({ shortName: 'abc' }),
+      schema,
+    );
+    expect(html).toContain('data-emoji-short-name="abc"');
+    expect(html).toContain('contenteditable="false"');
+  });
+
+  it('should extract the correct values of emoji (minimal representation)', () => {
+    const doc = fromHTML("<span data-emoji-short-name='abc'></span>");
+    const emoji = doc.firstChild!.firstChild!;
+
+    expect(emoji.type.name).toEqual('emoji');
+    expect(emoji.attrs.shortName).toEqual('abc');
+    expect(emoji.attrs.id).toEqual('');
+    expect(emoji.attrs.text).toEqual('');
+  });
+
+  it('should extract the correct values of emoji from bitbucket (minimal representation)', () => {
+    const doc = fromHTML(
+      '<img class="emoji" data-emoji-short-name="abc" data-emoji-id="123" data-emoji-text="xyz"></img>',
+    );
+    const emoji = doc.firstChild!.firstChild!;
+
+    expect(emoji.type.name).toEqual('emoji');
+    expect(emoji.attrs.shortName).toEqual('abc');
+    expect(emoji.attrs.id).toEqual('123');
+    expect(emoji.attrs.text).toEqual('xyz');
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text', 'emoji'],
+  });
+}

package/src/__tests__/unit/schema/nodes/expand.ts

@@ -0,0 +1,51 @@
+import { toDOM, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+import { expand } from '../../../..';
+import { schema } from 'adf-test-helpers/src/adf-schema'
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema expand node`, () => {
+  describe('parse html', () => {
+    it('converts to PM node', () => {
+      const doc = fromHTML('<div data-node-type="expand" />', schema);
+      const node = doc.firstChild!;
+      expect(node.type.spec).toEqual(expand);
+    });
+
+    it('gets attributes from html', () => {
+      const title = 'Homer Simpson';
+      const doc = fromHTML(
+        `
+        <div
+          data-node-type="expand"
+          data-title="${title}"
+        ><p>hello</p></div>
+      `,
+        schema,
+      );
+
+      const node = doc.firstChild!;
+      expect(node.attrs.title).toEqual(title);
+    });
+  });
+
+  describe('encode html', () => {
+    it('converts html data attributes to node attributes', () => {
+      const title = 'Homer Simpson';
+      const content = schema.nodes.paragraph.create(schema.text('hello'));
+      const node = schema.nodes.expand.create({ title }, content);
+      const dom = toDOM(node, schema).firstChild as HTMLElement;
+
+      expect(dom.getAttribute('data-node-type')).toEqual('expand');
+      expect(dom.getAttribute('data-title')).toEqual(title);
+    });
+
+    it('encodes and decodes to the same node', () => {
+      const title = 'Homer Simpson';
+      const content = schema.nodes.paragraph.create(schema.text('hello'));
+      const node = schema.nodes.expand.create({ title }, content);
+      const dom = toDOM(node, schema).firstChild as HTMLElement;
+      const parsedNode = fromHTML(dom.outerHTML, schema).firstChild!;
+      expect(parsedNode).toEqual(node);
+    });
+  });
+});

package/src/__tests__/unit/schema/nodes/extension.ts

@@ -0,0 +1,101 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { toDOM, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+import { extension } from '../../../..';
+import { dataConsumer } from '../../../..';
+import { Schema } from '@atlaskit/editor-prosemirror/model';
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema extension node`, () => {
+  let schema: Schema;
+  beforeEach(() => {
+    schema = makeSchema();
+  });
+  describe('parse html', () => {
+    it('parses a dataConsumer mark correctly', () => {
+      const extensionHtml =
+        '<div data-node-type="extension" data-extension-type="com.example.ext" data-extension-key="gallery" />';
+      const withDataConsumerMark = `<span data-mark-type="dataConsumer" data-sources="[&quot;someid&quot;]">${extensionHtml}</span>`;
+      const doc = fromHTML(withDataConsumerMark, schema);
+      const extensionNode = doc.firstChild!;
+      const dataConsumerMark = doc.firstChild!.marks[0];
+      expect(dataConsumerMark.type.spec).toEqual(dataConsumer);
+      expect(extensionNode.type.spec).toEqual(extension);
+    });
+
+    it('converts to extension PM node', () => {
+      const doc = fromHTML(
+        '<div data-node-type="extension" data-extension-type="com.example.ext" data-extension-key="gallery" />',
+        schema,
+      );
+      const node = doc.firstChild!;
+      expect(node.type.spec).toEqual(extension);
+    });
+
+    it('gets attributes from html', () => {
+      const extensionType = 'com.atlassian.confluence.macro.core';
+      const extensionKey = 'gallery';
+      const parameters = { macroparams: { width: '100px' } };
+
+      const doc = fromHTML(
+        `
+        <div
+          data-node-type="extension"
+          data-extension-type="${extensionType}"
+          data-extension-key="${extensionKey}"
+          data-parameters='${JSON.stringify(parameters)}'
+        />
+      `,
+        schema,
+      );
+
+      const node = doc.firstChild!;
+      expect(node.attrs.extensionType).toEqual(extensionType);
+      expect(node.attrs.extensionKey).toEqual(extensionKey);
+      expect(node.attrs.parameters).toEqual(parameters);
+    });
+  });
+
+  describe('encode html', () => {
+    it('converts html data attributes to node attributes', () => {
+      const attrs = {
+        extensionType: 'com.atlassian.confluence.macro.core',
+        extensionKey: 'gallery',
+        parameters: { macroparams: { width: '100px' } },
+      };
+      // extension node can contain no content
+      const node = schema.nodes.extension.create(attrs);
+      const dom = toDOM(node, schema).firstChild as HTMLElement;
+
+      expect(dom.getAttribute('data-node-type')).toEqual('extension');
+      expect(dom.getAttribute('data-extension-type')).toEqual(
+        attrs.extensionType,
+      );
+      expect(dom.getAttribute('data-extension-key')).toEqual(
+        attrs.extensionKey,
+      );
+      expect(dom.getAttribute('data-parameters')).toEqual(
+        JSON.stringify(attrs.parameters),
+      );
+    });
+
+    it('encodes and decodes to the same node', () => {
+      const attrs = {
+        extensionType: 'com.atlassian.confluence.macro.core',
+        extensionKey: 'gallery',
+        parameters: { macroparams: { width: '100px' } },
+      };
+      const node = schema.nodes.extension.create(attrs);
+      const dom = toDOM(node, schema).firstChild as HTMLElement;
+      const parsedNode = fromHTML(dom.outerHTML, schema).firstChild!;
+      expect(parsedNode).toEqual(node);
+    });
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text', 'extension'],
+    marks: ['dataConsumer'],
+  });
+}

package/src/__tests__/unit/schema/nodes/hard-break.ts

@@ -0,0 +1,24 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { toHTML, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+const schema = makeSchema();
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema hardBreak node`, () => {
+  it('serializes to <br>', () => {
+    const html = toHTML(schema.nodes.hardBreak.create(), schema);
+    expect(html).toContain('<br>');
+  });
+
+  it('matches <br>', () => {
+    const doc = fromHTML('<br>', schema);
+    const br = doc.firstChild!.firstChild!;
+    expect(br.type.name).toEqual('hardBreak');
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text', 'hardBreak'],
+  });
+}

package/src/__tests__/unit/schema/nodes/heading.ts

@@ -0,0 +1,56 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { fromHTML, toHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+import {
+  strong,
+  doc as editorDoc,
+  h1,
+  a as link,
+  em,
+} from 'adf-test-helpers/src/doc-builder';
+
+const schema = makeSchema();
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema heading node`, () => {
+  it('serializes to <h4>', () => {
+    const html = toHTML(schema.nodes.heading.create({ level: 4 }), schema);
+    expect(html).toContain('<h4>');
+  });
+
+  it('matches <h3>', () => {
+    const doc = fromHTML('<h3>', schema);
+    const h3 = doc.firstChild!;
+    expect(h3.type.name).toEqual('heading');
+  });
+
+  it('can have inline strong', () => {
+    const doc = fromHTML('<h1><b>hello</b></h1>', schema);
+    expect(doc.toJSON()).toEqual(
+      editorDoc(h1(strong('hello')))(schema).toJSON(),
+    );
+  });
+
+  it('can have inline italic', () => {
+    const doc = fromHTML('<h1><em>hello</em></h1>', schema);
+    expect(doc.toJSON()).toEqual(editorDoc(h1(em('hello')))(schema).toJSON());
+  });
+
+  it('can have inline links', () => {
+    const doc = fromHTML(
+      '<h1><a href="http://www.atlassian.com" rel="nofollow" title="@abodera" class="mention mention-me">hello</a></h1>',
+      schema,
+    );
+    expect(doc.toJSON()).toEqual(
+      editorDoc(h1(link({ href: 'http://www.atlassian.com' })('hello')))(
+        schema,
+      ).toJSON(),
+    );
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text', 'heading'],
+    marks: ['strong', 'em', 'link'],
+  });
+}

package/src/__tests__/unit/schema/nodes/image.ts

@@ -0,0 +1,32 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { fromHTML, toHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+const schema = makeSchema();
+const src = 'http://test.com';
+const srcDataURI = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAY)';
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema image node`, () => {
+  it('serializes to <img>', () => {
+    const html = toHTML(schema.nodes.image.create({ src }), schema);
+    expect(html).toContain(`<img src="${src}" alt="">`);
+  });
+
+  it('matches <img src="...">', () => {
+    const doc = fromHTML(`<img src="${src}" />`, schema);
+    const img = doc.firstChild!.firstChild!;
+    expect(img.type.name).toEqual('image');
+  });
+
+  it('does not match <img src="data:image/...">', () => {
+    const doc = fromHTML(`<img src="${srcDataURI}" />`, schema);
+    const img = doc.firstChild!.firstChild!;
+    expect(img).toBeNull();
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text', 'image'],
+  });
+}

package/src/__tests__/unit/schema/nodes/inline-card.ts

@@ -0,0 +1,106 @@
+import { toDOM, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+import { createSchema } from '../../../../schema/create-schema';
+import { inlineCard } from '../../../../schema/nodes/inline-card';
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema inlineCard node`, () => {
+  const schema = createSchema({
+    nodes: ['doc', 'paragraph', 'inlineCard', 'text'],
+  });
+
+  const url = 'https://product-fabric.atlassian.net/browse/ED-1';
+  const data = {
+    '@type': 'Document',
+    generator: {
+      '@type': 'Application',
+      name: 'Confluence',
+    },
+    url: 'https://extranet.atlassian.com/pages/viewpage.action?pageId=3088533424',
+    name: 'Founder Update 76: Hello, Trello!',
+    summary:
+      'Today is a big day for Atlassian – we have entered into an agreement to buy Trello. (boom)',
+  };
+
+  describe('inlineCard with "url" attribute', () => {
+    describe('parse html', () => {
+      it('converts to inlineCard PM node', () => {
+        const doc = fromHTML(`<a data-inline-card href="${url}" />`, schema);
+        const node = doc.firstChild!.firstChild!;
+        expect(node.type.spec).toEqual(inlineCard);
+      });
+
+      it('gets attributes from html', () => {
+        const doc = fromHTML(`<a data-inline-card href="${url}" />`, schema);
+
+        const node = doc.firstChild!.firstChild!;
+        expect(node.attrs.url).toEqual(url);
+        expect(node.attrs.data).toEqual(null);
+      });
+    });
+
+    describe('encode html', () => {
+      it('converts html data attributes to node attributes', () => {
+        const dom = toDOM(schema.nodes.inlineCard.create({ url }), schema)
+          .firstChild as HTMLElement;
+
+        expect(dom.getAttribute('href')).toEqual(url);
+      });
+
+      it('encodes and decodes to the same node', () => {
+        const node = schema.nodes.inlineCard.create({ url });
+        const dom = toDOM(node, schema).firstChild as HTMLElement;
+        const parsedNode = fromHTML(dom.outerHTML, schema).firstChild!
+          .firstChild!;
+        expect(parsedNode).toEqual(node);
+      });
+    });
+  });
+
+  describe('inlineCard with "data" attribute', () => {
+    describe('parse html', () => {
+      it('converts to inlineCard PM node', () => {
+        const doc = fromHTML(
+          `<a data-inline-card href="" data-card-data='${JSON.stringify(
+            data,
+          )}' />`,
+          schema,
+        );
+        const node = doc.firstChild!.firstChild!;
+        expect(node.type.spec).toEqual(inlineCard);
+      });
+
+      it('gets attributes from html', () => {
+        const doc = fromHTML(
+          `<a data-inline-card href="" data-card-data='${JSON.stringify(
+            data,
+          )}' />`,
+          schema,
+        );
+
+        const node = doc.firstChild!.firstChild!;
+        expect(node.attrs.data).toEqual(data);
+      });
+    });
+
+    describe('encode html', () => {
+      it('converts html data attributes to node attributes', () => {
+        const dom = toDOM(schema.nodes.inlineCard.create({ data }), schema)
+          .firstChild as HTMLElement;
+
+        expect(dom.getAttribute('href')).toEqual('');
+        expect(dom.getAttribute('data-card-data')).toEqual(
+          JSON.stringify(data),
+        );
+      });
+
+      it('encodes and decodes to the same node', () => {
+        const node = schema.nodes.inlineCard.create({ url });
+        const dom = toDOM(node, schema).firstChild as HTMLElement;
+        const parsedNode = fromHTML(dom.outerHTML, schema).firstChild!
+          .firstChild!;
+        expect(parsedNode).toEqual(node);
+      });
+    });
+  });
+});

package/src/__tests__/unit/schema/nodes/inline-extension.ts

@@ -0,0 +1,79 @@
+import { toDOM, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+import { inlineExtension } from '../../../..';
+import { schema } from 'adf-test-helpers/src/adf-schema'
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema inlineExtension node`, () => {
+  describe('parse html', () => {
+    it('converts to inlineExtension PM node', () => {
+      const doc = fromHTML(
+        '<span data-extension-type="com.atlassian.confluence.macro" data-extension-key="status" />',
+        schema,
+      );
+      const node = doc.firstChild!.firstChild!;
+      expect(node.type.spec).toEqual(inlineExtension);
+    });
+
+    it('gets attributes from html', () => {
+      const extensionType = 'com.atlassian.confluence.macro';
+      const extensionKey = 'status';
+      const parameters = { color: 'yellow', text: 'In progress' };
+
+      const doc = fromHTML(
+        `
+        <span
+          data-extension-type="${extensionType}"
+          data-extension-key="${extensionKey}"
+          data-parameters='${JSON.stringify(parameters)}'
+        />
+      `,
+        schema,
+      );
+
+      const node = doc.firstChild!.firstChild!;
+      expect(node.attrs.extensionType).toEqual(extensionType);
+      expect(node.attrs.extensionKey).toEqual(extensionKey);
+      expect(node.attrs.parameters).toEqual(parameters);
+    });
+  });
+
+  describe('encode html', () => {
+    it('converts html data attributes to node attributes', () => {
+      const attrs = {
+        extensionType: 'com.atlassian.confluence.macro',
+        extensionKey: 'status',
+        parameters: {
+          macroparams: { color: 'green', text: 'Decided' },
+        },
+      };
+      const dom = toDOM(schema.nodes.inlineExtension.create(attrs), schema)
+        .firstChild as HTMLElement;
+
+      expect(dom.getAttribute('data-extension-type')).toEqual(
+        attrs.extensionType,
+      );
+      expect(dom.getAttribute('data-extension-key')).toEqual(
+        attrs.extensionKey,
+      );
+      expect(dom.getAttribute('data-parameters')).toEqual(
+        JSON.stringify(attrs.parameters),
+      );
+    });
+
+    it('encodes and decodes to the same node', () => {
+      const attrs = {
+        extensionType: 'com.atlassian.confluence.macro',
+        extensionKey: 'status',
+        parameters: {
+          macroparams: { color: 'red', text: 'At risk' },
+        },
+      };
+      const node = schema.nodes.inlineExtension.create(attrs);
+      const dom = toDOM(node, schema).firstChild as HTMLElement;
+      const parsedNode = fromHTML(dom.outerHTML, schema).firstChild!
+        .firstChild!;
+      expect(parsedNode).toEqual(node);
+    });
+  });
+});