@khanacademy/wonder-blocks-testing 0.0.2

package/src/fixtures/__tests__/combine-top-level.test.js

@@ -0,0 +1,100 @@
+// @flow
+import * as WonderStuffCoreModule from "@khanacademy/wonder-stuff-core";
+
+import {combineTopLevel} from "../combine-top-level.js";
+
+jest.mock("@khanacademy/wonder-stuff-core");
+
+describe("#combine", () => {
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    it.each([undefined, null, 42, "test", true])(
+        "should return a clone of val2 if val1 is %s",
+        (val1) => {
+            // Arrange
+            jest.spyOn(WonderStuffCoreModule, "clone").mockImplementation(
+                (v) => `CLONED: ${v}`,
+            );
+            const val2 = "VALUE2";
+
+            // Act
+            const result = combineTopLevel(val1, val2);
+
+            // Assert
+            expect(result).toEqual(`CLONED: VALUE2`);
+        },
+    );
+
+    it("should return a deduplicated array including values from val1 and val2, with val2 values first if both are arrays", () => {
+        // Arrange
+        jest.spyOn(WonderStuffCoreModule, "clone").mockImplementation((v) => v);
+        const val1 = ["VALUE1", "VALUE2", "VALUE2"];
+        const val2 = ["VALUE2", "VALUE3", "VALUE3"];
+
+        // Act
+        const result = combineTopLevel(val1, val2);
+
+        // Assert
+        expect(result).toEqual(["VALUE1", "VALUE2", "VALUE3"]);
+    });
+
+    it("should return a clone of val2 if val2 is an array but val1 is not", () => {
+        // Arrange
+        jest.spyOn(WonderStuffCoreModule, "clone").mockImplementation(
+            (v) => `CLONED: ${v}`,
+        );
+        const val1 = "VALUE1";
+        const val2 = ["VALUE1", "VALUE2", "VALUE3"];
+
+        // Act
+        const result = combineTopLevel(val1, val2);
+
+        // Assert
+        expect(result).toEqual("CLONED: VALUE1,VALUE2,VALUE3");
+    });
+
+    it("should return a clone of val2 if val2 is not an array but val1 is", () => {
+        // Arrange
+        jest.spyOn(WonderStuffCoreModule, "clone").mockImplementation(
+            (v) => `CLONED: ${JSON.stringify(v)}`,
+        );
+        const val1 = ["VALUE1", "VALUE2", "VALUE3"];
+        const val2 = {
+            key1: "VALUE1",
+        };
+
+        // Act
+        const result = combineTopLevel(val1, val2);
+
+        // Assert
+        expect(result).toEqual('CLONED: {"key1":"VALUE1"}');
+    });
+
+    it("should return a combination of val1 and val2 (cloned) properties with val2 overriding val1 when both are non-array objects", () => {
+        // Arrange
+        jest.spyOn(WonderStuffCoreModule, "clone").mockImplementation((v) => v);
+        const val1 = {
+            a: "val1_VALUE1",
+            b: "val1_VALUE2",
+            c: "val1_VALUE3",
+        };
+        const val2 = {
+            b: "val2_VALUE2",
+            c: "val2_VALUE3",
+            d: "val2_VALUE4",
+        };
+
+        // Act
+        const result = combineTopLevel(val1, val2);
+
+        // Assert
+        expect(result).toEqual({
+            a: "val1_VALUE1",
+            b: "val2_VALUE2",
+            c: "val2_VALUE3",
+            d: "val2_VALUE4",
+        });
+    });
+});

package/src/fixtures/__tests__/fixtures.test.js

@@ -0,0 +1,483 @@
+// @flow
+import * as SetupModule from "../setup.js";
+import * as CombineOptionsModule from "../combine-options.js";
+import {fixtures} from "../fixtures.js";
+
+jest.mock("../setup.js");
+jest.mock("../combine-options.js");
+
+describe("#fixtures", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("should declare a group on the configured adapter with the given title and description", () => {
+        // Arrange
+        const fakeGroup = {
+            closeGroup: jest.fn(),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+        });
+
+        // Act
+        fixtures(
+            {
+                title: "TITLE",
+                description: "DESCRIPTION",
+                component: () => "COMPONENT",
+            },
+            jest.fn(),
+        );
+
+        // Assert
+        expect(adapter.declareGroup).toHaveBeenCalledWith({
+            title: "TITLE",
+            description: "DESCRIPTION",
+        });
+    });
+
+    it("should default the title to the component.displayName in the absence of title", () => {
+        // Arrange
+        const fakeGroup = {
+            closeGroup: jest.fn(),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+        });
+        const component = () => "COMPONENT";
+        component.displayName = "DISPLAYNAME";
+
+        // Act
+        fixtures(
+            {
+                component,
+            },
+            jest.fn(),
+        );
+
+        // Assert
+        expect(adapter.declareGroup).toHaveBeenCalledWith({
+            title: "DISPLAYNAME",
+        });
+    });
+
+    it("should default the title to the component.name in the absence of component.displayName", () => {
+        // Arrange
+        const fakeGroup = {
+            closeGroup: jest.fn(),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+        });
+        const component = function FUNCTIONNAME() {
+            return "COMPONENT";
+        };
+
+        // Act
+        fixtures(
+            {
+                component,
+            },
+            jest.fn(),
+        );
+
+        // Assert
+        expect(adapter.declareGroup).toHaveBeenCalledWith({
+            title: "FUNCTIONNAME",
+        });
+    });
+
+    it("should default the title to 'Component' in the absence of component.name", () => {
+        // Arrange
+        const fakeGroup = {
+            closeGroup: jest.fn(),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+        });
+
+        // Act
+        fixtures(
+            {
+                component: ({}: any),
+            },
+            jest.fn(),
+        );
+
+        // Assert
+        expect(adapter.declareGroup).toHaveBeenCalledWith({
+            title: "Component",
+        });
+    });
+
+    it("should invoke the passed fn with function argument", () => {
+        // Arrange
+        const fakeGroup = {
+            declareFixture: jest.fn(),
+            closeGroup: jest.fn(),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+        });
+        const fn = jest.fn();
+
+        // Act
+        fixtures(
+            {
+                title: "GROUP_TITLE",
+                description: "GROUP_DESCRIPTION",
+                component: () => "COMPONENT",
+            },
+            fn,
+        );
+
+        // Assert
+        expect(fn).toHaveBeenCalledWith(expect.any(Function));
+    });
+
+    it("should combine additionalAdapterOptions for the appropriate adapter with defaultAdapterOptions", () => {
+        // Arrange
+        const combineOptionsSpy = jest.spyOn(
+            CombineOptionsModule,
+            "combineOptions",
+        );
+        const fakeGroup = {
+            declareFixture: jest.fn(),
+            closeGroup: jest.fn(),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        const defaultAdapterOptions = {
+            foo: "bar",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+            defaultAdapterOptions,
+        });
+        const additionalTestAdapterOptions = {
+            bim: "bop",
+        };
+
+        // Act
+        fixtures(
+            {
+                component: () => "COMPONENT",
+                additionalAdapterOptions: {
+                    testadapter: additionalTestAdapterOptions,
+                    otheradapterwedontcareabout: {
+                        fig: "fug",
+                    },
+                },
+            },
+            jest.fn(),
+        );
+
+        // Assert
+        expect(combineOptionsSpy).toHaveBeenCalledWith(
+            defaultAdapterOptions,
+            additionalTestAdapterOptions,
+        );
+    });
+
+    it("should call group.closeGroup with the combined adapter options", () => {
+        // Arrange
+        jest.spyOn(CombineOptionsModule, "combineOptions").mockReturnValue(
+            "COMBINED_OPTIONS",
+        );
+        const fakeGroup = {
+            declareFixture: jest.fn(),
+            closeGroup: jest.fn(),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        const defaultAdapterOptions = {
+            foo: "bar",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+            defaultAdapterOptions,
+        });
+        const additionalTestAdapterOptions = {
+            bim: "bop",
+        };
+
+        // Act
+        fixtures(
+            {
+                component: () => "COMPONENT",
+                additionalAdapterOptions: {
+                    testadapter: additionalTestAdapterOptions,
+                    otheradapterwedontcareabout: {
+                        fig: "fug",
+                    },
+                },
+            },
+            jest.fn(),
+        );
+
+        // Assert
+        expect(fakeGroup.closeGroup).toHaveBeenCalledWith("COMBINED_OPTIONS");
+    });
+
+    it("should return the result of group.closeGroup", () => {
+        // Arrange
+        const fakeGroup = {
+            declareFixture: jest.fn(),
+            closeGroup: jest.fn().mockReturnValue("RESULT"),
+        };
+        const adapter = {
+            declareGroup: jest.fn().mockReturnValue(fakeGroup),
+            name: "testadapter",
+        };
+        jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+            adapter,
+        });
+
+        // Act
+        const result = fixtures(
+            {
+                component: () => "COMPONENT",
+            },
+            jest.fn(),
+        );
+
+        // Assert
+        expect(result).toEqual("RESULT");
+    });
+
+    describe("injected fixture fn", () => {
+        it("should call group.declareFixture with description and props getter", () => {
+            // Arrange
+            const fakeGroup = {
+                declareFixture: jest.fn(),
+                closeGroup: jest.fn(),
+            };
+            const adapter = {
+                declareGroup: jest.fn().mockReturnValue(fakeGroup),
+                name: "testadapter",
+            };
+            jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+                adapter,
+            });
+            const component = () => "COMPONENT";
+
+            // Act
+            fixtures(
+                {
+                    title: "GROUP_TITLE",
+                    description: "GROUP_DESCRIPTION",
+                    component,
+                },
+                (fixture) => {
+                    fixture("FIXTURE_DESCRIPTION", {these: "areProps"});
+                },
+            );
+
+            // Assert
+            expect(fakeGroup.declareFixture).toHaveBeenCalledWith({
+                description: "FIXTURE_DESCRIPTION",
+                getProps: expect.any(Function),
+                component,
+            });
+        });
+
+        it("should pass wrapper component to group.declareFixture", () => {
+            // Arrange
+            const fakeGroup = {
+                declareFixture: jest.fn(),
+                closeGroup: jest.fn(),
+            };
+            const adapter = {
+                declareGroup: jest.fn().mockReturnValue(fakeGroup),
+                name: "testadapter",
+            };
+            jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+                adapter,
+            });
+            const defaultWrapper = () => "DEFAULT_WRAPPER";
+            const wrapper = () => "WRAPPER";
+
+            // Act
+            fixtures(
+                {
+                    title: "GROUP_TITLE",
+                    description: "GROUP_DESCRIPTION",
+                    component: () => "COMPONENT",
+                    defaultWrapper,
+                },
+                (fixture) => {
+                    fixture(
+                        "FIXTURE_DESCRIPTION",
+                        {these: "areProps"},
+                        wrapper,
+                    );
+                },
+            );
+
+            // Assert
+            expect(fakeGroup.declareFixture).toHaveBeenCalledWith({
+                description: "FIXTURE_DESCRIPTION",
+                getProps: expect.any(Function),
+                component: wrapper,
+            });
+        });
+
+        it("should pass defaultWrapper component to group.declareFixture if no wrapper", () => {
+            // Arrange
+            const fakeGroup = {
+                declareFixture: jest.fn(),
+                closeGroup: jest.fn(),
+            };
+            const adapter = {
+                declareGroup: jest.fn().mockReturnValue(fakeGroup),
+                name: "testadapter",
+            };
+            jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+                adapter,
+            });
+            const defaultWrapper = () => "DEFAULT_WRAPPER";
+
+            // Act
+            fixtures(
+                {
+                    title: "GROUP_TITLE",
+                    description: "GROUP_DESCRIPTION",
+                    component: () => "COMPONENT",
+                    defaultWrapper,
+                },
+                (fixture) => {
+                    fixture("FIXTURE_DESCRIPTION", {these: "areProps"});
+                },
+            );
+
+            // Assert
+            expect(fakeGroup.declareFixture).toHaveBeenCalledWith({
+                description: "FIXTURE_DESCRIPTION",
+                getProps: expect.any(Function),
+                component: defaultWrapper,
+            });
+        });
+
+        describe("getProps fn passed to group.declareFixture", () => {
+            it("should return the props when props is an object", () => {
+                // Arrange
+                const fakeGroup = {
+                    declareFixture: jest.fn(),
+                    closeGroup: jest.fn(),
+                };
+                const adapter = {
+                    declareGroup: jest.fn().mockReturnValue(fakeGroup),
+                    name: "testadapter",
+                };
+                jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+                    adapter,
+                });
+
+                // Act
+                fixtures(
+                    {
+                        component: () => "COMPONENT",
+                    },
+                    (fixture) => {
+                        fixture("FIXTURE_DESCRIPTION", {these: "areProps"});
+                    },
+                );
+                const getPropsFn =
+                    fakeGroup.declareFixture.mock.calls[0][0].getProps;
+                const result = getPropsFn("OPTIONS");
+
+                // Assert
+                expect(result).toEqual({these: "areProps"});
+            });
+
+            it("should invoke the props function with given options when props is a function", () => {
+                // Arrange
+                const fakeGroup = {
+                    declareFixture: jest.fn(),
+                    closeGroup: jest.fn(),
+                };
+                const adapter = {
+                    declareGroup: jest.fn().mockReturnValue(fakeGroup),
+                    name: "testadapter",
+                };
+                jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+                    adapter,
+                });
+                const props = jest.fn().mockReturnValue({these: "areProps"});
+
+                // Act
+                fixtures(
+                    {
+                        component: () => "COMPONENT",
+                    },
+                    (fixture) => {
+                        fixture("FIXTURE_DESCRIPTION", props);
+                    },
+                );
+                const getPropsFn =
+                    fakeGroup.declareFixture.mock.calls[0][0].getProps;
+                getPropsFn("OPTIONS");
+
+                // Assert
+                expect(props).toHaveBeenCalledWith("OPTIONS");
+            });
+
+            it("should return the result of the props function when props is a function", () => {
+                // Arrange
+                const fakeGroup = {
+                    declareFixture: jest.fn(),
+                    closeGroup: jest.fn(),
+                };
+                const adapter = {
+                    declareGroup: jest.fn().mockReturnValue(fakeGroup),
+                    name: "testadapter",
+                };
+                jest.spyOn(SetupModule, "getConfiguration").mockReturnValue({
+                    adapter,
+                });
+                const props = jest.fn().mockReturnValue({these: "areProps"});
+
+                // Act
+                fixtures(
+                    {
+                        component: () => "COMPONENT",
+                    },
+                    (fixture) => {
+                        fixture("FIXTURE_DESCRIPTION", props);
+                    },
+                );
+                const getPropsFn =
+                    fakeGroup.declareFixture.mock.calls[0][0].getProps;
+                const result = getPropsFn("OPTIONS");
+
+                // Assert
+                expect(result).toEqual({these: "areProps"});
+            });
+        });
+    });
+});

package/src/fixtures/__tests__/setup.test.js

@@ -0,0 +1,69 @@
+// @flow
+import {isolateModules} from "../../jest/isolate-modules.js";
+
+describe("#getConfiguration", () => {
+    it("should return the configuration passed during setup", () => {
+        // Arrange
+        const {setup, getConfiguration} = isolateModules(() =>
+            require("../setup.js"),
+        );
+        const configuration = {
+            adapter: {
+                name: "mytestadapter",
+                declareGroup: jest.fn(),
+            },
+            defaultAdapterOptions: {},
+        };
+        setup(configuration);
+
+        // Act
+        const result = getConfiguration();
+
+        // Assert
+        expect(result).toBe(configuration);
+    });
+
+    it("should throw if setup has not been performed", () => {
+        // Arrange
+        const {getConfiguration} = isolateModules(() => require("../setup.js"));
+
+        // Act
+        const underTest = () => getConfiguration();
+
+        // Assert
+        expect(underTest).toThrowErrorMatchingInlineSnapshot(
+            `"Not configured"`,
+        );
+    });
+});
+
+describe("#setup", () => {
+    it("should set the configuration returned by getConfiguration", () => {
+        // Arrange
+        const {setup, getConfiguration} = isolateModules(() =>
+            require("../setup.js"),
+        );
+        const configuration1 = {
+            adapter: {
+                name: "mytestadapter1",
+                declareGroup: jest.fn(),
+            },
+            defaultAdapterOptions: {},
+        };
+        const configuration2 = {
+            adapter: {
+                name: "mytestadapter2",
+                declareGroup: jest.fn(),
+            },
+            defaultAdapterOptions: {},
+        };
+
+        // Act
+        setup(configuration1);
+        setup(configuration2);
+        const result = getConfiguration();
+
+        // Assert
+        expect(result).toBe(configuration2);
+    });
+});

package/src/fixtures/adapters/__tests__/__snapshots__/adapter-group.test.js.snap

@@ -0,0 +1,9 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`AdapterGroup #constructor should throw if options are not valid (a string) 1`] = `"options must be an object"`;
+
+exports[`AdapterGroup #constructor should throw if options are not valid (null) 1`] = `"options must be an object"`;
+
+exports[`AdapterGroup #declareFixture should throw if options are not valid (a string) 1`] = `"options must be an object"`;
+
+exports[`AdapterGroup #declareFixture should throw if options are not valid (null) 1`] = `"options must be an object"`;

package/src/fixtures/adapters/__tests__/__snapshots__/adapter.test.js.snap

@@ -0,0 +1,13 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Adapter #constructor should throw if closeGroupFn is invalid 1`] = `"closeGroupFn must be a function"`;
+
+exports[`Adapter #constructor should throw if closeGroupFn is invalid 2`] = `"closeGroupFn must be a function"`;
+
+exports[`Adapter #constructor should throw if the name is invalid (     ) 1`] = `"name must be a non-empty string"`;
+
+exports[`Adapter #constructor should throw if the name is invalid () 1`] = `"name must be a non-empty string"`;
+
+exports[`Adapter #constructor should throw if the name is invalid (8) 1`] = `"name must be a string"`;
+
+exports[`Adapter #constructor should throw if the name is invalid (null) 1`] = `"name must be a string"`;