@khanacademy/perseus 0.0.1 → 0.2.1

package/src/multi-items/__tests__/items_test.js

@@ -0,0 +1,245 @@
+// @flow
+
+import {
+    buildEmptyItemTreeForShape,
+    buildEmptyItemForShape,
+    findContentNodesInItem,
+    findHintNodesInItem,
+    inferItemShape,
+    itemToTree,
+    treeToItem,
+} from "../items.js";
+import shapes from "../shapes.js";
+
+import type {
+    Item,
+    ItemTree,
+    ContentNode,
+    HintNode,
+    TagsNode,
+    ItemArrayNode,
+} from "../item-types.js";
+
+describe("treeToItem", () => {
+    it("wraps an item tree in the `_multi` key", () => {
+        const tree = {__type: "hint"};
+        expect({_multi: tree}).toEqual(treeToItem(tree));
+    });
+});
+
+describe("itemToTree", () => {
+    it("unwraps an item tree from the `_multi` key", () => {
+        const tree = {__type: "hint"};
+        expect(tree).toEqual(itemToTree({_multi: tree}));
+    });
+});
+
+describe("buildEmptyItemTreeForShape and buildEmptyItemForShape", () => {
+    const expectedEmptyContentNode = {
+        content: "",
+        images: {},
+        widgets: {},
+        __type: "content",
+    };
+
+    const expectedEmptyHintNode = {
+        replace: false,
+        content: "",
+        images: {},
+        widgets: {},
+        __type: "hint",
+    };
+
+    function assertEmptyItemTreeForShape(expectedEmptyTree: ItemTree, shape) {
+        const emptyTree = buildEmptyItemTreeForShape(shape);
+        expect(emptyTree).toEqual(expectedEmptyTree);
+
+        const expectedEmptyItem = treeToItem(expectedEmptyTree);
+        const emptyItem = buildEmptyItemForShape(shape);
+        expect(emptyItem).toEqual(expectedEmptyItem);
+    }
+
+    it("creates an empty item", () => {
+        assertEmptyItemTreeForShape(expectedEmptyContentNode, shapes.content);
+    });
+
+    it("creates an empty hint", () => {
+        assertEmptyItemTreeForShape(expectedEmptyHintNode, shapes.hint);
+    });
+
+    it("creates empty tags", () => {
+        assertEmptyItemTreeForShape(([]: TagsNode), shapes.tags);
+    });
+
+    it("creates an empty array", () => {
+        assertEmptyItemTreeForShape(
+            ([]: ItemArrayNode),
+            shapes.arrayOf(shapes.content),
+        );
+    });
+
+    it("creates an empty object containing all node types", () => {
+        const shape = shapes.shape({
+            instructions: shapes.content,
+            hint: shapes.hint,
+            questions: shapes.arrayOf(shapes.content),
+            context: shapes.shape({
+                prompt: shapes.content,
+                footnotes: shapes.content,
+            }),
+        });
+        const expectedEmptyTree = {
+            instructions: expectedEmptyContentNode,
+            hint: expectedEmptyHintNode,
+            questions: ([]: ItemArrayNode),
+            context: {
+                prompt: expectedEmptyContentNode,
+                footnotes: expectedEmptyContentNode,
+            },
+        };
+        assertEmptyItemTreeForShape(expectedEmptyTree, shape);
+    });
+});
+
+describe("inferItemShape", () => {
+    it("infers a content node's shape", () => {
+        const item = buildEmptyItemForShape(shapes.content);
+        expect(shapes.content).toEqual(inferItemShape(item));
+    });
+
+    // TODO(mdr): Remove #LegacyContentNode support.
+    it("infers a legacy content node's shape", () => {
+        const item = {
+            _multi: {
+                __type: "item",
+                content: "",
+                images: {},
+                widgets: {},
+            },
+        };
+        expect(shapes.content).toEqual(inferItemShape(item));
+    });
+
+    it("infers a hint node's shape", () => {
+        const item = buildEmptyItemForShape(shapes.hint);
+        expect(shapes.hint).toEqual(inferItemShape(item));
+    });
+
+    it("infers a tags node's shape", () => {
+        const item = treeToItem((["foo", "bar"]: TagsNode));
+        expect(shapes.tags).toEqual(inferItemShape(item));
+    });
+
+    it("infers an object node's shape", () => {
+        const shape = shapes.shape({
+            content: shapes.content,
+            hint: shapes.hint,
+        });
+        const item = buildEmptyItemForShape(shape);
+        expect(shape).toEqual(inferItemShape(item));
+    });
+
+    it("poorly infers an empty array node's shape", () => {
+        const item = treeToItem(([]: ItemArrayNode));
+        expect(shapes.arrayOf(shapes.content)).toEqual(inferItemShape(item));
+    });
+
+    it("correctly infers an nonempty single-typed array node's shape", () => {
+        const item = treeToItem(
+            ([
+                /**
+                 * TODO(somewhatabstract, JIRA-XXXX):
+                 * The Tree types are really hard to work with properly.
+                 */
+                // $FlowFixMe[incompatible-cast]
+                buildEmptyItemTreeForShape(shapes.hint),
+                // $FlowFixMe[incompatible-cast]
+                buildEmptyItemTreeForShape(shapes.hint),
+                // $FlowFixMe[incompatible-cast]
+                buildEmptyItemTreeForShape(shapes.hint),
+            ]: ItemArrayNode),
+        );
+        expect(shapes.arrayOf(shapes.hint)).toEqual(inferItemShape(item));
+    });
+
+    it("poorly infers an invalid multi-type array node's shape", () => {
+        const item = treeToItem(
+            ([
+                /**
+                 * TODO(somewhatabstract, JIRA-XXXX):
+                 * The Tree types are really hard to work with properly.
+                 */
+                // $FlowFixMe[incompatible-cast]
+                buildEmptyItemTreeForShape(shapes.hint),
+                // $FlowFixMe[incompatible-cast]
+                buildEmptyItemTreeForShape(shapes.content),
+                // $FlowFixMe[incompatible-cast]
+                buildEmptyItemTreeForShape(shapes.hint),
+            ]: ItemArrayNode),
+        );
+        expect(shapes.arrayOf(shapes.hint)).toEqual(inferItemShape(item));
+    });
+});
+
+function content(n): ContentNode {
+    return {
+        __type: "content",
+        content: `content ${n}`,
+    };
+}
+
+function hint(n): HintNode {
+    return {
+        __type: "hint",
+        content: `hint ${n}`,
+    };
+}
+
+const shape = shapes.shape({
+    a: shapes.content,
+    b: shapes.arrayOf(shapes.content),
+    c: shapes.shape({
+        d: shapes.content,
+        e: shapes.hint,
+    }),
+    f: shapes.hint,
+});
+
+const item: Item = treeToItem({
+    a: content(1),
+    /**
+     * TODO(somewhatabstract, JIRA-XXXX):
+     * The Tree types are really hard to work with properly.
+     */
+    // $FlowFixMe[incompatible-cast]
+    b: ([content(2), content(3), content(4)]: ItemArrayNode),
+    c: {
+        d: content(5),
+        e: hint(6),
+    },
+    f: hint(7),
+});
+
+describe("findContentNodesInItem", () => {
+    it("calls the callback for each content node in the item", () => {
+        const contents = [];
+        findContentNodesInItem(item, shape, (c) => contents.push(c));
+        contents.sort();
+        expect([
+            content(1),
+            content(2),
+            content(3),
+            content(4),
+            content(5),
+        ]).toEqual(contents);
+    });
+});
+
+describe("findHintNodesInItem", () => {
+    it("calls the callback for each hint node in the item", () => {
+        const hints = [];
+        findHintNodesInItem(item, shape, (c) => hints.push(c));
+        hints.sort();
+        expect([hint(6), hint(7)]).toEqual(hints);
+    });
+});