gt-sanity 0.0.5 → 1.0.0

package/src/serialization/__tests__/BaseDocumentSerializer/documentLevelSerialization.test.ts

@@ -0,0 +1,120 @@
+import { PortableTextBlock } from 'sanity';
+import { describe, expect, test } from 'vitest';
+import { getSerialized, getValidFields, toPlainText } from '../helpers';
+import { documentLevelArticle, findByClass, getHTMLNode } from './utils';
+
+const serialized = getSerialized(documentLevelArticle, 'document');
+const docTree = getHTMLNode(serialized).body.children[0];
+
+test('Global test of working doc-level functionality and snapshot match', () => {
+  expect(serialized).toMatchSnapshot();
+});
+/*
+ * Top-level plain text
+ */
+test('String and text types get serialized correctly at top-level', () => {
+  const HTMLString = findByClass(docTree.children, 'title');
+  const HTMLText = findByClass(docTree.children, 'snippet');
+  expect(HTMLString?.innerHTML).toEqual(documentLevelArticle.title);
+  expect(HTMLText?.innerHTML).toEqual(documentLevelArticle.snippet);
+});
+
+/*
+ * Presence and accuracy of fields
+ */
+describe('Presence and accuracy of fields in "vanilla" deserialization -- objects', () => {
+  //parent node is always div with classname of field with a nested div
+  //that has classname of obj type
+  const configObj = findByClass(docTree.children, 'config');
+  const objectField = configObj!.children[0];
+
+  test('Top-level nested objects contain all serializable fields -- document level', () => {
+    const fieldNames = getValidFields(documentLevelArticle.config);
+    const foundFieldNames = Array.from(objectField!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+
+  test('Nested object in object contains all serializable fields -- document level', () => {
+    const nestedObject = findByClass(objectField!.children, 'objectAsField')!
+      .children[0];
+    const fieldNames = getValidFields(
+      documentLevelArticle.config.objectAsField
+    );
+    const foundFieldNames = Array.from(nestedObject!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+
+  test('Nested object contains accurate values -- document level', () => {
+    const title = documentLevelArticle.config.title;
+    const blockText = toPlainText(documentLevelArticle.config.nestedArrayField);
+
+    expect(objectField?.innerHTML).toContain(title);
+    expect(objectField?.innerHTML).toContain(blockText);
+  });
+
+  test('Nested object in an object contains accurate values -- document level', () => {
+    const nestedObject = findByClass(objectField!.children, 'objectAsField')!
+      .children[0];
+    const title = documentLevelArticle.config.objectAsField.title;
+    const blockText = toPlainText(
+      documentLevelArticle.config.objectAsField.content
+    );
+
+    expect(nestedObject.innerHTML).toContain(title);
+    expect(nestedObject.innerHTML).toContain(blockText);
+  });
+});
+
+describe('Presence and accuracy of fields in vanilla deserialization -- arrays', () => {
+  const arrayField = findByClass(docTree.children, 'content');
+
+  test('Array contains all serializable blocks with keys, in order -- document level', () => {
+    const origKeys = documentLevelArticle.content.map(
+      (block: PortableTextBlock) => block._key
+    );
+    const serializedKeys = Array.from(arrayField!.children).map(
+      (block) => block.id
+    );
+    expect(serializedKeys).toEqual(origKeys);
+  });
+
+  test('Array contains top-level block text -- document level', () => {
+    const blockText = toPlainText(documentLevelArticle.content).trim();
+    const blockStrings = blockText.split('\n\n');
+    blockStrings.forEach((substring: string) =>
+      expect(arrayField?.innerHTML).toContain(substring)
+    );
+  });
+
+  test('Object in array contains all serializable fields -- document level', () => {
+    const objectInArray = findByClass(arrayField!.children, 'objectField');
+    const fieldNames = getValidFields(
+      documentLevelArticle.content.find(
+        (block: Record<string, any>) => block._type === 'objectField'
+      )
+    );
+    const foundFieldNames = Array.from(objectInArray!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+
+  test('Object in array contains accurate values in nested object -- document level', () => {
+    const objectInArray = findByClass(arrayField!.children, 'objectField');
+    const nestedObject = findByClass(objectInArray!.children, 'objectAsField');
+    const title = documentLevelArticle.content.find(
+      (block: Record<string, any>) => block._type === 'objectField'
+    ).objectAsField.title;
+    const blockText = toPlainText(
+      documentLevelArticle.content.find(
+        (block: Record<string, any>) => block._type === 'objectField'
+      ).objectAsField.content
+    ).trim();
+    expect(nestedObject?.innerHTML).toContain(title);
+    expect(nestedObject?.innerHTML).toContain(blockText);
+  });
+});

package/src/serialization/__tests__/BaseDocumentSerializer/fieldLevelSerialization.test.ts

@@ -0,0 +1,153 @@
+import { PortableTextBlock } from 'sanity';
+import { describe, expect, test } from 'vitest';
+import { getSerialized, getValidFields, toPlainText } from '../helpers';
+import {
+  fieldLevelArticle,
+  findByClass,
+  getHTMLNode,
+  nestedLanguageFields,
+} from './utils';
+
+const serialized = getSerialized(fieldLevelArticle, 'field');
+const docTree = getHTMLNode(serialized).body.children[0];
+
+test('Global test of working field-level functionality and snapshot match', () => {
+  expect(serialized).toMatchSnapshot();
+});
+
+test('String and text types get serialized correctly at top-level -- field level', () => {
+  const titleObj = findByClass(docTree.children, 'title')?.children[0];
+  const HTMLString = findByClass(titleObj!.children, 'en');
+  const snippetObj = findByClass(docTree.children, 'snippet')?.children[0];
+  const HTMLText = findByClass(snippetObj!.children, 'en');
+  expect(HTMLString?.innerHTML).toEqual(fieldLevelArticle.title.en);
+  expect(HTMLText?.innerHTML).toEqual(fieldLevelArticle.snippet.en);
+});
+
+describe('Presence and accuracy of fields in "vanilla" deserialization -- objects', () => {
+  const getFieldLevelObjectField = () => {
+    const config = findByClass(docTree.children, 'config')?.children[0];
+    //return english field
+    const englishConfig = findByClass(config!.children, 'en');
+    return findByClass(englishConfig!.children, 'objectField');
+  };
+
+  const objectField = getFieldLevelObjectField();
+
+  test('Top-level nested objects contain all serializable fields -- field level', () => {
+    const fieldNames = getValidFields(fieldLevelArticle.config.en);
+    const foundFieldNames = Array.from(objectField!.children).map(
+      (child) => child.className
+    );
+
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+
+  test('Nested object in object contains all serializable fields -- field Level', () => {
+    const nestedObject = findByClass(objectField!.children, 'objectAsField')!
+      .children[0];
+    const fieldNames = getValidFields(
+      fieldLevelArticle.config.en.objectAsField
+    );
+    const foundFieldNames = Array.from(nestedObject!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+
+  test('Nested object contains accurate values -- field level', () => {
+    const title = fieldLevelArticle.config.en.title;
+    const blockText = toPlainText(fieldLevelArticle.config.en.nestedArrayField);
+
+    expect(objectField?.innerHTML).toContain(title);
+    expect(objectField?.innerHTML).toContain(blockText);
+  });
+
+  test('Nested object in an object contains accurate values -- field level', () => {
+    const nestedObject = findByClass(objectField!.children, 'objectAsField')!
+      .children[0];
+    const title = fieldLevelArticle.config.en.objectAsField.title;
+    const blockText = toPlainText(
+      fieldLevelArticle.config.en.objectAsField.content
+    );
+
+    expect(nestedObject.innerHTML).toContain(title);
+    expect(nestedObject.innerHTML).toContain(blockText);
+  });
+});
+
+/*
+ * Presence and accuracy of fields in "vanilla" deserialization -- arrays
+ */
+describe('Presence and accurancy of fields in "vanilla" deserialization -- arrays', () => {
+  const getFieldLevelArrayField = () => {
+    const content = findByClass(docTree.children, 'content')?.children[0];
+    return findByClass(content!.children, 'en');
+  };
+  const arrayField = getFieldLevelArrayField();
+
+  test('Array contains all serializable blocks with keys, in order -- field level', () => {
+    const origKeys = fieldLevelArticle.content.en.map(
+      (block: PortableTextBlock) => block._key
+    );
+    const serializedKeys = Array.from(arrayField!.children).map(
+      (block) => block.id
+    );
+    expect(serializedKeys).toEqual(origKeys);
+  });
+
+  test('Array contains top-level block text -- field level', () => {
+    const blockText = toPlainText(fieldLevelArticle.content.en).trim();
+    expect(arrayField?.innerHTML).toContain(blockText);
+  });
+
+  test('Object in array contains all serializable fields -- field level', () => {
+    const objectInArray = findByClass(arrayField!.children, 'objectField');
+    const fieldNames = getValidFields(
+      fieldLevelArticle.content.en.find(
+        (block: Record<string, any>) => block._type === 'objectField'
+      )
+    );
+    const foundFieldNames = Array.from(objectInArray!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+
+  test('Object in array contains accurate values in nested object -- field level', () => {
+    const objectInArray = findByClass(arrayField!.children, 'objectField');
+    const nestedObject = findByClass(objectInArray!.children, 'objectAsField');
+    const title = fieldLevelArticle.content.en.find(
+      (block: Record<string, any>) => block._type === 'objectField'
+    ).objectAsField.title;
+    const blockText = toPlainText(
+      fieldLevelArticle.content.en.find(
+        (block: Record<string, any>) => block._type === 'objectField'
+      ).objectAsField.content
+    ).trim();
+    expect(nestedObject?.innerHTML).toContain(title);
+    expect(nestedObject?.innerHTML).toContain(blockText);
+  });
+});
+
+test('Nested locale fields make it to serialization, but only base lang', () => {
+  const nestedLocales = { ...fieldLevelArticle, ...nestedLanguageFields };
+  const nestedSerialized = getSerialized(nestedLocales, 'field');
+  const nestedDocTree = getHTMLNode(nestedSerialized).body.children[0];
+  const slices = findByClass(nestedDocTree.children, 'slices');
+  const pageFields = findByClass(nestedDocTree.children, 'pageFields');
+  expect(slices?.innerHTML).toContain(
+    nestedLanguageFields.slices[0].en[0].children[0].text
+  );
+  expect(pageFields?.innerHTML).toContain(
+    nestedLanguageFields.pageFields.name.en
+  );
+  expect(slices?.innerHTML).not.toContain(
+    nestedLanguageFields.slices[0].fr_FR[0].children[0].text
+  );
+  expect(pageFields?.innerHTML).not.toContain(
+    nestedLanguageFields.pageFields.name.fr_FR
+  );
+});
+
+//also test: setting different base language!

package/src/serialization/__tests__/BaseDocumentSerializer/utils.ts

@@ -0,0 +1,27 @@
+import { createRequire } from 'module';
+
+import { SerializedDocument } from '../../types';
+
+const require = createRequire(import.meta.url);
+
+export { default as inlineSchema } from '../__fixtures__/inlineSchema';
+export { default as schema } from '../__fixtures__/schema';
+export const documentLevelArticle = require('../__fixtures__/documentLevelArticle.json');
+export const docWithInlineMarks = require('../__fixtures__/documentInlineMarks.json');
+export const inlineDocumentLevelArticle = require('../__fixtures__/inlineDocumentLevelArticle.json');
+export const fieldLevelArticle = require('../__fixtures__/fieldLevelArticle.json');
+export const annotationAndInlineBlocks = require('../__fixtures__/annotationAndInlineBlocks.json');
+export const nestedLanguageFields = require('../__fixtures__/nestedLanguageFields.json');
+
+export const getHTMLNode = (serialized: SerializedDocument): Document => {
+  const htmlString = serialized.content;
+  const parser = new DOMParser();
+  return parser.parseFromString(htmlString, 'text/html');
+};
+
+export const findByClass = (
+  children: HTMLCollection,
+  className: string
+): Element | undefined => {
+  return Array.from(children).find((node) => node.className === className);
+};

package/src/serialization/__tests__/README

@@ -0,0 +1,2 @@
+Files in this directory are adapted from https://github.com/sanity-io/sanity-naive-html-serializer
+and are licensed under MIT. See LICENSE.md for more details.

package/src/serialization/__tests__/__fixtures__/annotationAndInlineBlocks.json

@@ -0,0 +1,140 @@
+{
+  "content": [
+    {
+      "_key": "6fe9a3ecaf0f",
+      "style": "normal",
+      "markDefs": [],
+      "_type": "block",
+      "listItem": "number",
+      "level": 1,
+      "children": [
+        {
+          "_type": "span",
+          "marks": [],
+          "text": "",
+          "_key": "47eb0224d6b5"
+        },
+        {
+          "_key": "d3dcb15f4bfe",
+          "_type": "childObjectField",
+          "title": "This is an inline object in a top-level block list"
+        }
+      ]
+    },
+    {
+      "_key": "a1b026261117",
+      "_type": "block",
+      "markDefs": [],
+      "style": "normal",
+      "level": 2,
+      "listItem": "number",
+      "children": [
+        {
+          "_key": "d3dcb15f4bfe",
+          "_type": "childObjectField",
+          "title": "This is an inline object in a nested list item"
+        }
+      ]
+    },
+    {
+      "_key": "0e55995095df",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "a94d5e26cc99",
+          "_type": "span",
+          "marks": [],
+          "text": "This is block "
+        },
+        {
+          "_key": "3d31216296ab",
+          "_type": "span",
+          "marks": ["2f5ec56ab061"],
+          "text": "text"
+        },
+        {
+          "_key": "d669ccc1799e",
+          "_type": "span",
+          "marks": [],
+          "text": " at the top level. "
+        },
+        {
+          "_key": "0871af4fa11c",
+          "_type": "childObjectField",
+          "title": "This is an inline object in a top-level block text field"
+        },
+        {
+          "_key": "be01d00a77a2",
+          "_type": "span",
+          "marks": [],
+          "text": ""
+        }
+      ],
+      "markDefs": [
+        {
+          "_key": "2f5ec56ab061",
+          "_type": "annotation",
+          "content": [
+            {
+              "_key": "f94daf68d620",
+              "_type": "block",
+              "children": [
+                {
+                  "_key": "0f9944aec4a2",
+                  "_type": "span",
+                  "marks": [],
+                  "text": "This is an annotation on the word \"text\" on block-level content"
+                }
+              ],
+              "markDefs": [],
+              "style": "normal"
+            }
+          ],
+          "title": "Annotation"
+        }
+      ],
+      "style": "normal"
+    },
+    {
+      "_key": "7e1268803bda",
+      "_type": "objectField",
+      "nestedArrayField": [
+        {
+          "_key": "40703bc96a33",
+          "_type": "block",
+          "children": [
+            {
+              "_key": "103500a73aa4",
+              "_type": "span",
+              "marks": [],
+              "text": "This is block text in a nested object."
+            }
+          ],
+          "markDefs": [],
+          "style": "normal"
+        }
+      ],
+      "objectAsField": {
+        "_type": "childObjectField",
+        "content": [
+          {
+            "_key": "663b9b01b63a",
+            "_type": "block",
+            "children": [
+              {
+                "_key": "c64b6cda3790",
+                "_type": "span",
+                "marks": [],
+                "text": "This is block text in a nested object in an object in top-level block text."
+              }
+            ],
+            "markDefs": [],
+            "style": "normal"
+          }
+        ],
+        "title": "This is a nested object in an object in top-level block text."
+      },
+      "title": "This is an object in top-level block text."
+    }
+  ]
+}

package/src/serialization/__tests__/__fixtures__/customStyles.json

@@ -0,0 +1,62 @@
+{
+  "content": [
+    {
+      "_key": "a4d177e92666",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "a896ea6fcd59",
+          "_type": "span",
+          "marks": [],
+          "text": "This is block text at the top level."
+        }
+      ],
+      "markDefs": [],
+      "style": "custom1"
+    },
+    {
+      "_key": "6fe9a3ecaf0f",
+      "style": "custom1",
+      "markDefs": [],
+      "_type": "block",
+      "listItem": "number",
+      "level": 1,
+      "children": [
+        {
+          "_type": "span",
+          "marks": [],
+          "text": "This is custom-styled text in a list item",
+          "_key": "47eb0224d6b5"
+        }
+      ]
+    },
+    {
+      "_key": "9e2ab13c6d63",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "17e856dc4766",
+          "_type": "span",
+          "marks": [],
+          "text": "This is h1 text"
+        }
+      ],
+      "markDefs": [],
+      "style": "h1"
+    },
+    {
+      "_key": "297142fbaf21",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "0b2f9e94a161",
+          "_type": "span",
+          "marks": [],
+          "text": "This is h2 text"
+        }
+      ],
+      "markDefs": [],
+      "style": "h2"
+    }
+  ]
+}

package/src/serialization/__tests__/__fixtures__/documentInlineMarks.json

@@ -0,0 +1,70 @@
+{
+  "_id": "drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a",
+  "_rev": "fxcnqj-uew-gr7-v6r-z965tfm69",
+  "_type": "documentLevelArticle",
+  "_createdAt": "2021-09-01T23:00:13Z",
+  "_updatedAt": "2021-09-01T23:02:05Z",
+  "content": [
+    {
+      "_key": "a4d177e92666",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "a896ea6fcd59",
+          "_type": "span",
+          "marks": [],
+          "text": "This is block text with "
+        },
+        {
+          "_key": "b997fb7gce60",
+          "_type": "span",
+          "marks": ["topLink1"],
+          "text": "a website link"
+        },
+        {
+          "_key": "c008gc8hdf71",
+          "_type": "span",
+          "marks": [],
+          "text": " and "
+        },
+        {
+          "_key": "d119hd9ieg82",
+          "_type": "span",
+          "marks": ["topLink2"],
+          "text": "a post reference"
+        },
+        {
+          "_key": "e220ie0jfh93",
+          "_type": "span",
+          "marks": ["topLink1"],
+          "text": " at the top level."
+        }
+      ],
+      "markDefs": [
+        {
+          "_key": "topLink1",
+          "_type": "linkField",
+          "linkType": "href",
+          "href": "https://example.com",
+          "openInNewTab": true
+        },
+        {
+          "_key": "topLink2",
+          "_type": "linkField",
+          "linkType": "post",
+          "post": {
+            "_ref": "post-123-abc",
+            "_type": "reference"
+          },
+          "openInNewTab": false
+        }
+      ],
+      "style": "normal"
+    }
+  ],
+  "hidden": true,
+  "meta": "Do not translate this",
+  "snippet": "This is text in my text field.",
+  "tags": ["tag 1", "tag 2", "tag 3"],
+  "title": "My Document-Level Article"
+}