@atlaskit/adf-schema 36.13.0 → 36.14.1

package/schema-generators/__tests__/unit/validate-pm-schema.unit.ts

@@ -6,11 +6,132 @@ import {
   NodeSpecFactory,
 } from '@atlaskit/adf-schema-generator/src/transforms/adfToPm/createPMSpecFactory';
 import { defaultSchema } from '../../../src/schema/default-schema';
+import { printExpected, printReceived, matcherHint } from 'jest-matcher-utils';
+import { filterAndSortMarks, formatContent } from '../helpers/_utils';
+
+/**
+ * TODO: The EXCLUDE and SKIPPED consts are defined to pass the test
+ * Once following ticket is done, will need to remove exclude and unskip tests.
+ * https://product-fabric.atlassian.net/browse/ED-23488
+ */
+const EXCLUDE_CONTENT_FROM_NODESPEC = [
+  'uknownBlock', // We won't have it in DSL
+];
+const EXCLUDE_MARKS_FROM_NODESPEC = [
+  'confluenceInlineComment', // not exist in ADF DSL
+  'typeAheadQuery', // not exist in ADF DSL
+];
+const SKIPPED_MARKSPEC_TESTS = [
+  'link', // new link mark is not matching old link mark
+  'confluenceInlineComment', // not exist in ADF DSL
+  'unsupportedMark', // exist in ADF DSL but have default value where old spec doesn't have
+  'unsupportedNodeAttribute', // exist in ADF DSL but have default value where old spec doesn't have
+  'typeAheadQuery', // not exist in ADF DSL
+];
+const SKIPPED_NODESPEC_TESTS = [
+  'doc', // defined in ADF DSL, but not matching old spec
+  'unknownBlock', // not exist in new ADF DSL
+  'confluenceUnsupportedBlock', // not exist in new ADF DSL
+  'confluenceUnsupportedInline', // not exist in new ADF DSL
+  'confluenceJiraIssue', // not exist in new ADF DSL
+  'expand', // in ADF DSL, only expand.use('with_no_marks') is in use. Old spec have marks with 'dataConsumer, fragment'
+  'status', // has uuid localId in old spec
+  'nestedExpandWithNoMarks', // old nodeSpec have blockCard, but not in type NestedExpandContent, new DSL doesn't have blockCard as to match NestedExpandContent.
+  'hardBreak', // not aligned with old spec due to attr.text
+  'mediaInline', // not aligned with old spec due to attr.data
+  'image', // not exist in new ADF DSL
+  'mediaSingleFull', // not aligned with old spec - content is different
+  'table', // displayMode is default in new ADF DSL, but having null in old spec
+  'codeBlockWithNoMarks', // codeBlock doesn't have uniqueID in new ADF DSL, but have it in old spec.
+  'bodiedExtensionWithMarks', // old spec defaults to use bodiedExtension_with_marks_node, new DSL
+  'paragraph', // new ADF DSL have unsupporedInline, but not in old nodeSpec
+  'decisionItem', // new ADF DSL have unsupporedInline, but not in old nodeSpec
+  'taskItem', // new ADF DSL have unsupporedInline, but not in old nodeSpec
+  'heading', // new ADF DSL have unsupporedInline, but not in old nodeSpec
+  'blockquoteWithList', // new ADF DSL have unsupportedMark unsupportedNodeAttribute, but not in old nodeSpec
+  'layoutSection', // new ADF DSL doesn't have unsupportedBlock*|unsupportedBlock+ in content
+  'mediaGroup', // old spec have attrs: {}, but not in new ADF DSL.
+];
+
+/**
+ *
+ * When the default schema is created, there's a nodesInOrder map being used to map node name to a node spec
+ * The mapped node spec could be a different variant, rather than the base one.
+ * https://bitbucket.org/atlassian/adf-schema/src/main/packages/adf-schema/src/schema/create-schema.ts#lines-143
+ *
+ * TODO: consider stage0 as well
+ */
+const defaultSchemaNodeSpecMap = () => {
+  return {
+    blockquote: 'blockquoteWithList',
+    extension: 'extensionWithMarks',
+    bodiedExtension: 'bodiedExtensionWithMarks',
+    inlineExtension: 'inlineExtensionWithMarks',
+    mediaSingle: 'mediaSingleFull',
+    nestedExpand: 'nestedExpandWithNoMarks',
+    codeBlock: 'codeBlockWithNoMarks',
+  };
+};
+
+const getDefaultSpecName = (nodeName: string) => {
+  const customNodeSpecName = defaultSchemaNodeSpecMap()[nodeName];
+  return customNodeSpecName ? customNodeSpecName : nodeName;
+};
+
+const failMessage = (actual, expected, not) => () =>
+  `${matcherHint(
+    `${not ? '.not' : ''}.toMatchNodeSpec`,
+    'received',
+    'expected',
+  )}
+
+Expected nodeSpec${not ? ' not ' : ' '}to be equal:
+  
+Expected: ${printExpected(expected)}
+Received: ${printReceived(actual)}`;
+
+declare let expect: any;
+expect.extend({
+  toMatchNodeSpec(actual: NodeSpec, expected: NodeSpec) {
+    const formattedActual = {
+      ...actual,
+      ...(actual.content && { content: formatContent(actual.content) }),
+      ...(actual.marks && {
+        marks: filterAndSortMarks(actual.marks),
+      }),
+    };
+
+    const formattedExpected = {
+      ...expected,
+      ...(expected.content && {
+        content: formatContent(expected.content, EXCLUDE_CONTENT_FROM_NODESPEC),
+      }),
+      ...(expected.marks && {
+        marks: filterAndSortMarks(expected.marks, EXCLUDE_MARKS_FROM_NODESPEC),
+      }),
+    };
+
+    if (formattedExpected.marks === '') {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete formattedExpected['marks'];
+    }
+
+    const pass = this.equals(formattedActual, formattedExpected);
+    return {
+      pass,
+      message: failMessage(formattedActual, formattedExpected, pass),
+    };
+  },
+});
 
 function isMarkSpec(value: MarkSpec | NodeSpec): value is MarkSpec {
   return true;
 }
 
+function isNodeSpec(value: MarkSpec | NodeSpec): value is NodeSpec {
+  return true;
+}
+
 /**
  * Custom omit function, mainly used to filter out parseDOM and toDOM from old spec
  * and some special logic to filter out certain field when compare spec
@@ -18,7 +139,7 @@ function isMarkSpec(value: MarkSpec | NodeSpec): value is MarkSpec {
  * @param keys
  * @returns
  */
-function omit<T extends object>(data: T, keys: (keyof T)[]): T {
+function omit<T extends object>(data: T, keys = []): T {
   const result = { ...data };
   for (const k of keys) {
     // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
@@ -31,31 +152,27 @@ function omit<T extends object>(data: T, keys: (keyof T)[]): T {
       delete result['excludes'];
     }
   }
+  if (isNodeSpec(data)) {
+    // Treat inline: false same as no inline property
+    if (data.inline !== undefined && data.inline === false) {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete result['inline'];
+    }
+  }
   return result;
 }
 
 describe('validate PM schema', () => {
   describe('marks', () => {
     const { marks } = defaultSchema as Schema;
-    const skipLists = [
-      'link', // TODO: new link mark is not matching old link mark
-      'confluenceInlineComment', // TODO: not exist in ADF DSL
-      'unsupportedMark', // TODO: not exist in ADF DSL
-      'unsupportedNodeAttribute', // TODO: not exist in ADF DSL
-      'typeAheadQuery', // TODO: not exist in ADF DSL
-      // Following marks not exported in adf-schema
-      '__colorGroupDeclaration',
-      '__fontStyleGroupDeclaration',
-      '__searchQueryGroupDeclaration',
-      '__linkGroupDeclaration',
-    ];
+    const skipLists = SKIPPED_MARKSPEC_TESTS;
 
     const testCases = Object.entries(marks).map(([key, value]) => {
       return {
         name: key,
         legacyMarkSpec: value.spec,
-        newMarkSpecFn: newMarkSpecs[`${key}`] as MarkSpecFactory,
-        skip: skipLists.includes(key),
+        newMarkSpecFn: newMarkSpecs[key] as MarkSpecFactory,
+        skip: skipLists.includes(key) || key.startsWith('__'),
       };
     });
 
@@ -69,7 +186,7 @@ describe('validate PM schema', () => {
       testMethod(`validate markSpec for mark ${name}`, () => {
         // check if there's any missing markSpec
         expect(newMarkSpecFn).toBeDefined();
-        const newMarkSpec = newMarkSpecFn({});
+        const newMarkSpec = newMarkSpecFn<any>({});
         expect(omit(newMarkSpec, ['parseDOM', 'toDOM'])).toEqual(
           omit(legacyMarkSpec, ['parseDOM', 'toDOM']),
         );
@@ -77,34 +194,43 @@ describe('validate PM schema', () => {
     });
   });
 
-  // TODO: content from node is too strict, need a custom comparor
-  // TODO: marks are not matching, especially missing unsupportedBlock, unsupportedNodeAttribute
-  describe.skip('nodes', () => {
+  describe('nodes', () => {
     const { nodes } = defaultSchema as Schema;
-    const skipLists = ['unknownBlock', 'unsupportedBlock', 'unsupportedInline'];
+    const skipLists = SKIPPED_NODESPEC_TESTS;
     const testCases = Object.entries(nodes).map(([key, value]) => {
+      const specName = getDefaultSpecName(key);
       return {
-        name: key,
+        name: specName,
         legacyNodeSpec: value.spec,
-        newNodeSpecFn: newNodeSpecs[`${key}`] as NodeSpecFactory,
-        skip: skipLists.includes(key),
+        newNodeSpecFn: newNodeSpecs[specName] as NodeSpecFactory,
+        testingMethod: {
+          skip: skipLists.includes(specName),
+        },
       };
     });
 
-    const getTestingMethod = (skip: boolean) => {
-      return skip ? it.skip : it;
+    const getTestingMethod = ({ only = false, skip = false }) => {
+      if (skip) {
+        return it.skip;
+      }
+      if (only) {
+        return it.only;
+      }
+      return it;
     };
 
-    testCases.forEach(({ name, legacyNodeSpec, newNodeSpecFn, skip }) => {
-      const testMethod = getTestingMethod(skip);
-      testMethod(`validate nodeSpec for node ${name}`, () => {
-        // check if there's any missing nodeSpec
-        expect(newNodeSpecFn).toBeDefined();
-        const newNodeSpec = newNodeSpecFn({});
-        expect(omit(newNodeSpec, ['parseDOM', 'toDOM'])).toEqual(
-          omit(legacyNodeSpec, ['parseDOM', 'toDOM']),
-        );
-      });
-    });
+    testCases.forEach(
+      ({ name, legacyNodeSpec, newNodeSpecFn, testingMethod }) => {
+        const testMethod = getTestingMethod(testingMethod);
+        testMethod(`validate nodeSpec for node ${name}`, () => {
+          // check if there's any missing nodeSpec
+          expect(newNodeSpecFn).toBeDefined();
+          const newNodeSpec = newNodeSpecFn<any>({});
+          expect(omit(newNodeSpec, ['parseDOM', 'toDOM'])).toMatchNodeSpec(
+            omit(legacyNodeSpec, ['parseDOM', 'toDOM']),
+          );
+        });
+      },
+    );
   });
 });