level_0
int64 0
10k
| index
int64 0
0
| repo_id
stringlengths 22
152
| file_path
stringlengths 41
203
| content
stringlengths 11
11.5M
|
|---|---|---|---|---|
9,810 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/ButtonTabControl.test.tsx | import ButtonTabControl from "./ButtonTabControl";
const requiredParams = {
evaluatedValue: undefined,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
additionalDynamicData: {},
label: "",
propertyName: "",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
};
const options = [
{
startIcon: "text-bold",
value: "BOLD",
},
{
startIcon: "text-italic",
value: "ITALIC",
},
];
const config = { ...requiredParams, options };
describe("ButtonTabControl.canDisplayValue", () => {
it("Should return true when a value in the option is passed", () => {
expect(ButtonTabControl.canDisplayValueInUI(config, "BOLD")).toEqual(true);
expect(ButtonTabControl.canDisplayValueInUI(config, "ITALIC")).toEqual(
true,
);
expect(ButtonTabControl.canDisplayValueInUI(config, "ITALIC,BOLD")).toEqual(
true,
);
expect(ButtonTabControl.canDisplayValueInUI(config, "BOLD,ITALIC")).toEqual(
true,
);
});
it("Should return false when a value that is not in the option is passed", () => {
expect(ButtonTabControl.canDisplayValueInUI(config, "BLABLA")).toEqual(
false,
);
expect(ButtonTabControl.canDisplayValueInUI(config, "BOLD,BLABLA")).toEqual(
false,
);
});
});
|
9,814 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/ColorPickerComponentV2.test.tsx | import React from "react";
import { Provider } from "react-redux";
import "@testing-library/jest-dom";
import {
render,
screen,
waitForElementToBeRemoved,
} from "@testing-library/react";
import { ThemeProvider } from "styled-components";
import ColorPickerComponent from "./ColorPickerComponentV2";
import { lightTheme } from "selectors/themeSelectors";
import userEvent from "@testing-library/user-event";
import configureStore from "redux-mock-store";
const mockStore = configureStore([]);
const store = mockStore({
entities: {
canvasWidgets: {
0: {},
},
},
ui: {
appTheming: {
selectedTheme: {
properties: {
colors: {
primaryColor: "#553DE9",
backgroundColor: "#F8FAFC",
},
},
},
},
},
tenant: {
userPermissions: [],
tenantConfiguration: {
brandColors: {},
},
new: false,
},
});
const getTestComponent = (handleOnChange: any = undefined) => (
<Provider store={store}>
<ThemeProvider theme={lightTheme}>
<ColorPickerComponent
changeColor={handleOnChange}
color="#ffffff"
showApplicationColors
showThemeColors
/>
</ThemeProvider>
</Provider>
);
describe("<ColorPicker />", () => {
it("Clicking the input should open the colorpicker", () => {
render(getTestComponent());
expect(screen.queryByTestId("color-picker")).not.toBeInTheDocument();
screen.getByRole("textbox").click();
expect(screen.getByTestId("color-picker")).toBeInTheDocument();
});
it("Clicking the color inside input should open the colorpicker", () => {
render(getTestComponent());
expect(screen.queryByTestId("color-picker")).not.toBeInTheDocument();
(screen.getByRole("textbox")?.previousSibling as HTMLElement)?.click();
expect(screen.getByTestId("color-picker")).toBeInTheDocument();
});
it("Focusing the input using mouse should open the colorpicker and keep the focus on the input", () => {
render(getTestComponent());
expect(screen.queryByTestId("color-picker")).not.toBeInTheDocument();
// Simulating clicking and focus
screen.getByRole("textbox").focus();
screen.getByRole("textbox").click();
expect(screen.getByRole("textbox")).toHaveFocus();
expect(screen.getByTestId("color-picker")).toBeInTheDocument();
});
});
describe("<ColorPicker /> - Keyboard Navigation", () => {
it("Pressing tab should focus the component", () => {
render(getTestComponent());
userEvent.tab();
expect(screen.getByRole("textbox")).toHaveFocus();
});
it("Pressing {Enter} should open the colorpicker", () => {
render(getTestComponent());
userEvent.tab();
expect(screen.queryByTestId("color-picker")).toBeNull();
userEvent.keyboard("{Enter}");
expect(screen.queryByTestId("color-picker")).toBeInTheDocument();
});
it("Pressing {Escape} should close the colorpicker", async () => {
render(getTestComponent());
userEvent.tab();
expect(screen.queryByTestId("color-picker")).toBeNull();
userEvent.keyboard("{Enter}");
expect(screen.queryByTestId("color-picker")).toBeInTheDocument();
userEvent.keyboard("{Escape}");
await waitForElementToBeRemoved(screen.queryByTestId("color-picker"));
});
it("Pressing {Tab} should shift sections in the colorpicker", () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
userEvent.tab();
userEvent.tab();
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[0],
).toHaveFocus();
userEvent.tab();
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1],
).toHaveFocus();
// Back to first color
userEvent.tab();
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[0],
).toHaveFocus();
});
it("Pressing {ArrowRight} should shift focus to color to the right", () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
userEvent.tab();
userEvent.tab();
userEvent.tab();
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1],
).toHaveFocus();
userEvent.keyboard("{ArrowRight}");
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1]
.parentElement?.childNodes[1],
).toHaveFocus();
});
it("Pressing {ArrowLeft} should shift focus to color to the left", () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
userEvent.tab();
userEvent.tab();
userEvent.tab();
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1],
).toHaveFocus();
userEvent.keyboard("{ArrowRight}");
userEvent.keyboard("{ArrowRight}");
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1]
.parentElement?.childNodes[2],
).toHaveFocus();
userEvent.keyboard("{ArrowLeft}");
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1]
.parentElement?.childNodes[1],
).toHaveFocus();
});
it("Pressing {ArrowDown} should shift focus to color to the bottom", () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
userEvent.tab();
userEvent.tab();
userEvent.tab();
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1],
).toHaveFocus();
userEvent.keyboard("{ArrowDown}");
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1]
.parentElement?.childNodes[10],
).toHaveFocus();
});
it("Pressing {ArrowUp} should shift focus to color to the top", () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
userEvent.tab();
userEvent.tab();
userEvent.tab();
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1],
).toHaveFocus();
userEvent.keyboard("{ArrowRight}");
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowDown}");
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1]
.parentElement?.childNodes[21],
).toHaveFocus();
userEvent.keyboard("{ArrowUp}");
expect(
document.querySelectorAll("[tabindex='0'].t--colorpicker-v2-color")[1]
.parentElement?.childNodes[11],
).toHaveFocus();
});
it("Pressing {Enter} should select the color in focus", async () => {
const onColorChange = jest.fn();
render(getTestComponent(onColorChange));
userEvent.tab();
userEvent.keyboard("{Enter}");
userEvent.tab();
userEvent.tab();
userEvent.keyboard("{ArrowRight}");
userEvent.keyboard("{Enter}");
expect(onColorChange).toBeCalled();
await waitForElementToBeRemoved(screen.queryByTestId("color-picker"));
});
});
|
9,816 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/ColorPickerControl.test.tsx | import ColorPickerControl from "./ColorPickerControl";
const requiredParams = {
evaluatedValue: undefined,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
additionalDynamicData: {},
label: "",
propertyName: "",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
};
const config = { ...requiredParams };
describe("ColorPickerControl.canDisplayValue", () => {
it("Should return true when a value without binding is passed", () => {
expect(ColorPickerControl.canDisplayValueInUI(config, "red")).toEqual(true);
expect(ColorPickerControl.canDisplayValueInUI(config, "#ff0000")).toEqual(
true,
);
expect(ColorPickerControl.canDisplayValueInUI(config, "#f00")).toEqual(
true,
);
expect(
ColorPickerControl.canDisplayValueInUI(config, "rgba(255, 0, 0)"),
).toEqual(true);
});
it("Should return false when a value with binding is passed", () => {
expect(
ColorPickerControl.canDisplayValueInUI(config, "{{ Input1.text }}"),
).toEqual(false);
expect(
ColorPickerControl.canDisplayValueInUI(config, "{{ Input1.text }}ed"),
).toEqual(false);
});
});
|
9,823 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/DropDownControl.test.tsx | import { EditorTheme } from "components/editorComponents/CodeEditor/EditorConfig";
import { noop } from "lodash";
import type { DropDownControlProps } from "./DropDownControl";
import DropDownControl from "./DropDownControl";
const requiredParams: DropDownControlProps = {
evaluatedValue: undefined,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
placeholderText: "",
searchPlaceholderText: "",
additionalDynamicData: {},
label: "",
propertyName: "",
propertyValue: "1",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
openNextPanel: noop,
deleteProperties: noop,
theme: EditorTheme.LIGHT,
};
describe("DropDownControl.canDisplayValue", () => {
const options = [
{
label: "0",
value: 0,
},
{
label: "1",
value: 1,
},
{
label: "2",
value: 2,
},
{
label: "A",
value: "A",
},
];
const config = { ...requiredParams, options };
it("Should return true when a value in the option is passed", () => {
expect(DropDownControl.canDisplayValueInUI(config, "0")).toEqual(true);
expect(DropDownControl.canDisplayValueInUI(config, "1")).toEqual(true);
expect(DropDownControl.canDisplayValueInUI(config, "A")).toEqual(true);
});
it("Should return false when a value that is not in the option is passed", () => {
expect(DropDownControl.canDisplayValueInUI(config, "6")).toEqual(false);
});
});
describe("DropDownControl[isMultiSelect].canDisplayValue", () => {
const options = [
{
label: "0",
value: 0,
},
{
label: "1",
value: 1,
},
{
label: "2",
value: 2,
},
{
label: "A",
value: "A",
},
];
const config = { ...requiredParams, options, isMultiSelect: true };
it("Should return true when a value in the option is passed", () => {
expect(DropDownControl.canDisplayValueInUI(config, "[0]")).toEqual(true);
expect(DropDownControl.canDisplayValueInUI(config, "[1]")).toEqual(true);
expect(DropDownControl.canDisplayValueInUI(config, '["A"]')).toEqual(true);
});
it("Should return false when a value that is not in the option is passed", () => {
expect(DropDownControl.canDisplayValueInUI(config, "[6]")).toEqual(false);
});
it("Should return false when an invalid option is passed", () => {
expect(DropDownControl.canDisplayValueInUI(config, "0")).toEqual(false);
});
});
|
9,827 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/IconSelectControl.test.tsx | import React from "react";
import "@testing-library/jest-dom";
import {
render,
screen,
waitFor,
waitForElementToBeRemoved,
} from "@testing-library/react";
import IconSelectControl from "./IconSelectControl";
import userEvent from "@testing-library/user-event";
import { noop } from "lodash";
import { EditorTheme } from "components/editorComponents/CodeEditor/EditorConfig";
const requiredParams = {
evaluatedValue: undefined,
deleteProperties: noop,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
additionalDynamicData: {},
label: "",
openNextPanel: noop,
onPropertyChange: noop,
theme: EditorTheme.LIGHT,
propertyName: "iconName",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
};
const waitForParamsForSearchFocus = {
timeout: 3000,
};
describe("<IconSelectControl /> - Keyboard navigation", () => {
const getTestComponent = (
onPropertyChange: (
propertyName: string,
propertyValue: string,
isUpdatedViaKeyboard?: boolean,
) => void = noop,
) => (
<IconSelectControl
{...requiredParams}
onPropertyChange={onPropertyChange}
/>
);
it("Pressing tab should focus the component", () => {
render(getTestComponent());
userEvent.tab();
expect(screen.getByRole("button")).toHaveFocus();
});
it.each(["{Enter}", " ", "{ArrowDown}", "{ArrowUp}"])(
"Pressing '%s' should open the icon selector",
async (key) => {
render(getTestComponent());
userEvent.tab();
expect(screen.queryByRole("list")).toBeNull();
userEvent.keyboard(key);
expect(screen.queryByRole("list")).toBeInTheDocument();
// Makes sure search bar is having focus
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
},
);
it("Pressing '{Escape}' should close the icon selector", async () => {
render(getTestComponent());
userEvent.tab();
expect(screen.queryByRole("list")).toBeNull();
userEvent.keyboard("{Enter}");
expect(screen.queryByRole("list")).toBeInTheDocument();
userEvent.keyboard("{Escape}");
await waitForElementToBeRemoved(screen.getAllByRole("list"));
});
it("Pressing '{ArrowDown}' while search is in focus should remove the focus", async () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
expect(screen.queryByRole("list")).toBeInTheDocument();
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
userEvent.keyboard("{ArrowDown}");
expect(screen.queryByRole("textbox")).not.toHaveFocus();
});
it("Pressing '{Shift} + {ArrowUp}' while search is not in focus should focus search box", async () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
expect(screen.queryByRole("list")).toBeInTheDocument();
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
userEvent.keyboard("{ArrowDown}");
expect(screen.queryByRole("textbox")).not.toHaveFocus();
userEvent.keyboard("{Shift}{ArrowUp}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
});
/*
Icon Arrangement
(none) add add-column-left add-column-right
add-row-bottom add-row-top add-to-artifact add-to-folder
airplane align-center align-justify align-left
*/
it("Pressing '{ArrowDown}' should navigate the icon selection downwards", async () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
// used to shift the focus from search
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowDown}");
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
});
it("Pressing '{ArrowUp}' should navigate the icon selection upwards", async () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
// used to shift the focus from search
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowDown}");
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
userEvent.keyboard("{ArrowUp}");
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
});
it("Pressing '{ArrowRight}' should navigate the icon selection towards right", async () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
// used to shift the focus from search
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowRight}");
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
});
it("Pressing '{ArrowLeft}' should navigate the icon selection towards left", async () => {
render(getTestComponent());
userEvent.tab();
userEvent.keyboard("{Enter}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
// used to shift the focus from search
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowRight}");
userEvent.keyboard("{ArrowRight}");
userEvent.keyboard("{ArrowRight}");
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
userEvent.keyboard("{ArrowLeft}");
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
});
it("Pressing '{Enter}' or ' ' should select the icon", async () => {
const handleOnSelect = jest.fn();
render(getTestComponent(handleOnSelect));
userEvent.tab();
expect(screen.queryByRole("button")?.textContent).toEqual(
"(none)caret-down",
);
userEvent.keyboard("{Enter}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
// used to shift the focus from search
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowRight}");
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
userEvent.keyboard(" ");
expect(handleOnSelect).toHaveBeenCalledTimes(1);
expect(handleOnSelect.mock.calls[0]).toMatchSnapshot();
await waitForElementToBeRemoved(screen.getByRole("list"));
userEvent.keyboard("{Enter}");
expect(screen.queryByRole("list")).toBeInTheDocument();
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
userEvent.keyboard("{ArrowDown}");
userEvent.keyboard("{ArrowRight}");
userEvent.keyboard(" ");
expect(handleOnSelect).toHaveBeenCalledTimes(2);
expect(handleOnSelect.mock.calls[1]).toMatchSnapshot();
});
});
const config = { ...requiredParams };
describe("IconSelectControl.canDisplayValue", () => {
it("Should return true when a proper icon name is passed", () => {
expect(IconSelectControl.canDisplayValueInUI(config, "add")).toEqual(true);
expect(IconSelectControl.canDisplayValueInUI(config, "airplane")).toEqual(
true,
);
});
it("Should return false when a non-alowed icon value is passed", () => {
expect(IconSelectControl.canDisplayValueInUI(config, "macbook")).toEqual(
false,
);
});
});
describe("<IconSelectControl /> - (none) icon", () => {
const getTestComponent = (hideNoneIcon?: boolean) => (
<IconSelectControl {...requiredParams} hideNoneIcon={hideNoneIcon} />
);
it("Should display (none) icon when hideNoneIcon property is false/undefined", async () => {
render(getTestComponent());
userEvent.tab();
expect(screen.queryByRole("button")?.textContent).toEqual(
"(none)caret-down",
);
userEvent.keyboard("{Enter}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
// Check if the (none) icon is in the list
expect(screen.getByText("(none)", { selector: "div" })).toBeInTheDocument();
});
it("Should not display (none) icon when hideNoneIcon property is true", async () => {
render(getTestComponent(true));
userEvent.tab();
expect(screen.queryByRole("button")?.textContent).toEqual(
"(none)caret-down",
);
userEvent.keyboard("{Enter}");
await waitFor(() => {
expect(screen.queryByRole("textbox")).toHaveFocus();
}, waitForParamsForSearchFocus);
expect(
document.querySelector("a.bp3-active")?.children[0].classList,
).toMatchSnapshot();
// Check if the (none) icon is in the list
expect(screen.queryByText("(none)", { selector: "div" })).toBeNull();
});
});
|
9,829 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/IconTabControl.test.tsx | import IconTabControl from "./IconTabControl";
const requiredParams = {
evaluatedValue: undefined,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
additionalDynamicData: {},
label: "",
propertyName: "",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
};
const options = [
{
label: "0",
value: 0,
},
{
label: "1",
value: 1,
},
{
label: "2",
value: 2,
},
];
const config = { ...requiredParams, options };
describe("IconTabControl.canDisplayValue", () => {
it("Should return true when a value in the option is passed", () => {
expect(IconTabControl.canDisplayValueInUI(config, 0)).toEqual(true);
expect(IconTabControl.canDisplayValueInUI(config, 1)).toEqual(true);
});
it("Should return false when a value that is not in the option is passed", () => {
expect(IconTabControl.canDisplayValueInUI(config, 6)).toEqual(false);
});
});
|
9,840 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/NumericInputControl.test.ts | import NumericInputControl from "./NumericInputControl";
const config = {
evaluatedValue: undefined,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
additionalDynamicData: {},
label: "",
propertyName: "",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
};
describe("NumericInputControl.canDisplayValue", () => {
it("Should return true when a number is passed", () => {
expect(NumericInputControl.canDisplayValueInUI(config, "23")).toEqual(true);
expect(NumericInputControl.canDisplayValueInUI(config, "12")).toEqual(true);
expect(NumericInputControl.canDisplayValueInUI(config, "93.5")).toEqual(
true,
);
expect(NumericInputControl.canDisplayValueInUI(config, "-123")).toEqual(
true,
);
});
it("Should return false when a non number is passed", () => {
expect(NumericInputControl.canDisplayValueInUI(config, "abcd")).toEqual(
false,
);
expect(NumericInputControl.canDisplayValueInUI(config, "{{ 1 }}")).toEqual(
false,
);
});
});
|
9,851 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/StepControl.test.tsx | import StepControl from "./StepControl";
const requiredParams = {
evaluatedValue: undefined,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
additionalDynamicData: {},
label: "",
propertyName: "",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
};
const config = { ...requiredParams };
describe("StepControl.canDisplayValue", () => {
it("Checks for true cases for default value of stepType", () => {
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 1)).toEqual(true);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 9)).toEqual(true);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 5)).toEqual(true);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 75)).toEqual(true);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 25)).toEqual(true);
});
it("Checks for false cases for default value of stepType", () => {
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, -4)).toEqual(false);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 105)).toEqual(false);
});
it("Checks for true cases for 'ZOOM_PERCENTAGE' value of stepType", () => {
const config = { ...requiredParams, stepType: "ZOOM_PERCENTAGE" };
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 5)).toEqual(true);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 75)).toEqual(true);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 25)).toEqual(true);
});
it("Checks for false cases for 'ZOOM_PERCENTAGE' value of stepType", () => {
const config = { ...requiredParams, stepType: "ZOOM_PERCENTAGE" };
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 1)).toEqual(false);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 9)).toEqual(false);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, -4)).toEqual(false);
// @ts-expect-error: config does not have all keys
expect(StepControl.canDisplayValueInUI(config, 105)).toEqual(false);
});
});
|
9,854 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/SwitchControl.test.tsx | import SwitchControl from "./SwitchControl";
const requiredParams = {
evaluatedValue: undefined,
widgetProperties: undefined,
parentPropertyName: "",
parentPropertyValue: undefined,
additionalDynamicData: {},
label: "",
propertyName: "",
controlType: "",
isBindProperty: false,
isTriggerProperty: false,
};
const config = { ...requiredParams };
describe("SwitchControl.canDisplayValue", () => {
it("Should return true when 'true' or 'false' is passed", () => {
expect(SwitchControl.canDisplayValueInUI(config, "true")).toEqual(true);
expect(SwitchControl.canDisplayValueInUI(config, "false")).toEqual(true);
});
it("Should return false when a value other than 'true' or 'false' is passed", () => {
expect(SwitchControl.canDisplayValueInUI(config, "{{true}}")).toEqual(
false,
);
});
});
|
9,863 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls | petrpan-code/appsmithorg/appsmith/app/client/src/components/propertyControls/__snapshots__/IconSelectControl.test.tsx.snap | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`<IconSelectControl /> - (none) icon Should display (none) icon when hideNoneIcon property is false/undefined 1`] = `
DOMTokenList {
"0": "bp3-fill",
"1": "bp3-icon-(none)",
"2": "bp3-text-overflow-ellipsis",
}
`;
exports[`<IconSelectControl /> - (none) icon Should not display (none) icon when hideNoneIcon property is true 1`] = `undefined`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowDown}' should navigate the icon selection downwards 1`] = `
DOMTokenList {
"0": "bp3-fill",
"1": "bp3-icon-(none)",
"2": "bp3-text-overflow-ellipsis",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowDown}' should navigate the icon selection downwards 2`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-add-row-bottom",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowLeft}' should navigate the icon selection towards left 1`] = `
DOMTokenList {
"0": "bp3-fill",
"1": "bp3-icon-(none)",
"2": "bp3-text-overflow-ellipsis",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowLeft}' should navigate the icon selection towards left 2`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-add-column-right",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowLeft}' should navigate the icon selection towards left 3`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-add-column-left",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowRight}' should navigate the icon selection towards right 1`] = `
DOMTokenList {
"0": "bp3-fill",
"1": "bp3-icon-(none)",
"2": "bp3-text-overflow-ellipsis",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowRight}' should navigate the icon selection towards right 2`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-add",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowUp}' should navigate the icon selection upwards 1`] = `
DOMTokenList {
"0": "bp3-fill",
"1": "bp3-icon-(none)",
"2": "bp3-text-overflow-ellipsis",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowUp}' should navigate the icon selection upwards 2`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-align-right",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{ArrowUp}' should navigate the icon selection upwards 3`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-airplane",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{Enter}' or ' ' should select the icon 1`] = `
DOMTokenList {
"0": "bp3-fill",
"1": "bp3-icon-(none)",
"2": "bp3-text-overflow-ellipsis",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{Enter}' or ' ' should select the icon 2`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-add-row-top",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{Enter}' or ' ' should select the icon 3`] = `
Array [
"iconName",
"add-row-top",
true,
]
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{Enter}' or ' ' should select the icon 4`] = `
DOMTokenList {
"0": "bp3-icon",
"1": "bp3-icon-add-row-top",
}
`;
exports[`<IconSelectControl /> - Keyboard navigation Pressing '{Enter}' or ' ' should select the icon 5`] = `
Array [
"iconName",
"add-to-artifact",
true,
]
`;
|
9,911 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src | petrpan-code/appsmithorg/appsmith/app/client/src/constants/routes.test.ts | import urlBuilder from "@appsmith/entities/URLRedirect/URLAssembly";
import { builderURL, viewerURL } from "@appsmith/RouteBuilder";
describe("builderURL", () => {
let location: typeof window.location;
beforeAll(() => {
location = window.location;
delete (window as any).location;
urlBuilder.updateURLParams(
{
applicationSlug: ":applicationSlug",
applicationId: ":applicationId",
applicationVersion: 2,
},
[
{
pageId: ":pageId",
pageSlug: ":pageSlug",
},
],
);
});
it("persists embed query param", () => {
(window as any).location = new URL("https://example.com?embed=true");
const pageURL = builderURL({
pageId: ":pageId",
});
const pageURLObject = new URL(`${window.origin}${pageURL}`);
expect(pageURLObject.searchParams.get("embed")).toBe("true");
});
it("does not append embed query param when it does not exist", () => {
(window as any).location = new URL("https://example.com");
const pageURL = builderURL({
pageId: ":pageId",
});
const pageURLObject = new URL(`${window.origin}${pageURL}`);
expect(pageURLObject.searchParams.get("embed")).toBe(null);
});
afterAll(() => {
window.location = location;
jest.clearAllMocks();
});
});
describe("viewerURL", () => {
let location: typeof window.location;
beforeAll(() => {
location = window.location;
urlBuilder.updateURLParams(
{
applicationSlug: ":applicationSlug",
applicationId: ":applicationId",
applicationVersion: 2,
},
[
{
pageId: ":pageId",
pageSlug: ":pageSlug",
},
],
);
});
it("persists embed query param", () => {
(window as any).location = new URL("https://example.com?embed=true");
const pageURL = viewerURL({
pageId: ":pageId",
});
const pageURLObject = new URL(`${window.origin}${pageURL}`);
expect(pageURLObject.searchParams.get("embed")).toBe("true");
});
it("does not append embed query param when it does not exist", () => {
(window as any).location = new URL("https://example.com");
const pageURL = viewerURL({
pageId: ":pageId",
});
const pageURLObject = new URL(`${window.origin}${pageURL}`);
expect(pageURLObject.searchParams.get("embed")).toBe(null);
});
afterAll(() => {
window.location = location;
});
});
|
9,975 | 0 | petrpan-code/appsmithorg/appsmith/app/client/src/ee/entities | petrpan-code/appsmithorg/appsmith/app/client/src/ee/entities/DataTree/dataTreeJSAction.test.ts | export * from "ce/entities/DataTree/dataTreeJSAction.test";
|
45 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src | petrpan-code/alibaba/hooks/packages/hooks/src/__tests__/index.test.ts | import * as ahooks from '..';
describe('ahooks', () => {
test('exports modules should be defined', () => {
Object.keys(ahooks).forEach((module) => {
expect(ahooks[module]).toBeDefined();
});
});
});
|
47 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/createDeepCompareEffect | petrpan-code/alibaba/hooks/packages/hooks/src/createDeepCompareEffect/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import { useEffect, useLayoutEffect, useState } from 'react';
import { createDeepCompareEffect } from '../index';
describe('createDeepCompareEffect', () => {
it('should work for useEffect', async () => {
const useDeepCompareEffect = createDeepCompareEffect(useEffect);
const hook = renderHook(() => {
const [x, setX] = useState(0);
const [y, setY] = useState({ foo: 'foo', bar: ['baz'] });
useDeepCompareEffect(() => {
setX((prevX) => prevX + 1);
}, [y]);
return { x, setY };
});
expect(hook.result.current.x).toBe(1);
await act(async () => {
hook.result.current.setY({ foo: 'foo', bar: ['baz'] });
});
expect(hook.result.current.x).toBe(1);
await act(async () => {
hook.result.current.setY({ foo: 'foo', bar: ['bazz'] });
});
expect(hook.result.current.x).toBe(2);
});
it('should work for useLayoutEffect', async () => {
const useDeepCompareLayoutEffect = createDeepCompareEffect(useLayoutEffect);
const hook = renderHook(() => {
const [x, setX] = useState(0);
const [y, setY] = useState({ foo: 'foo', bar: ['baz'] });
useDeepCompareLayoutEffect(() => {
setX((prevX) => prevX + 1);
}, [y]);
return { x, setY };
});
expect(hook.result.current.x).toBe(1);
await act(async () => {
hook.result.current.setY({ foo: 'foo', bar: ['baz'] });
});
expect(hook.result.current.x).toBe(1);
await act(async () => {
hook.result.current.setY({ foo: 'foo', bar: ['bazz'] });
});
expect(hook.result.current.x).toBe(2);
});
it('deps is undefined should rerender in useEffect', async () => {
const useDeepCompareLayoutEffect = createDeepCompareEffect(useEffect);
let count = 0;
const hook = renderHook(() => {
useDeepCompareLayoutEffect(() => {
count++;
});
});
expect(count).toBe(1);
hook.rerender();
expect(count).toBe(2);
hook.rerender();
expect(count).toBe(3);
});
it('deps is undefined should rerender in useLayoutEffect', async () => {
const useDeepCompareLayoutEffect = createDeepCompareEffect(useLayoutEffect);
let count = 0;
const hook = renderHook(() => {
useDeepCompareLayoutEffect(() => {
count++;
});
});
expect(count).toBe(1);
hook.rerender();
expect(count).toBe(2);
hook.rerender();
expect(count).toBe(3);
});
});
|
49 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/createUpdateEffect | petrpan-code/alibaba/hooks/packages/hooks/src/createUpdateEffect/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import { useEffect, useLayoutEffect } from 'react';
import { createUpdateEffect } from '../index';
describe('createUpdateEffect', () => {
it('should work for useEffect', () => {
const useUpdateEffect = createUpdateEffect(useEffect);
let mountedState = 1;
const hook = renderHook(() =>
useUpdateEffect(() => {
mountedState = 2;
}),
);
expect(mountedState).toBe(1);
hook.rerender();
expect(mountedState).toBe(2);
});
it('should work for useLayoutEffect', () => {
const useUpdateLayoutEffect = createUpdateEffect(useLayoutEffect);
let mountedState = 1;
const hook = renderHook(() =>
useUpdateLayoutEffect(() => {
mountedState = 2;
}),
);
expect(mountedState).toBe(1);
hook.rerender();
expect(mountedState).toBe(2);
});
});
|
51 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/createUseStorageState | petrpan-code/alibaba/hooks/packages/hooks/src/createUseStorageState/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import type { Options } from '../index';
import { createUseStorageState } from '../index';
class TestStorage implements Storage {
[name: string]: any;
length: number = 0;
_values = new Map<string, string>();
clear(): void {
this._values.clear();
this.length = 0;
}
getItem(key: string): string | null {
return this._values.get(key) || null;
}
key(index: number): string | null {
if (index >= this._values.size) {
return null;
}
return Array.from(this._values.keys())[index];
}
removeItem(key: string): void {
if (this._values.delete(key)) {
this.length -= 1;
}
}
setItem(key: string, value: string): void {
if (!this._values.has(key)) {
this.length += 1;
}
this._values.set(key, value);
}
}
interface StorageStateProps<T> extends Pick<Options<T>, 'defaultValue'> {
key: string;
}
describe('useStorageState', () => {
const setUp = <T>(props: StorageStateProps<T>) => {
const storage = new TestStorage();
const useStorageState = createUseStorageState(() => storage);
return renderHook(
({ key, defaultValue }: StorageStateProps<T>) => {
const [state, setState] = useStorageState(key, { defaultValue });
return { state, setState };
},
{
initialProps: props,
},
);
};
it('should get defaultValue for a given key', () => {
const hook = setUp({ key: 'key1', defaultValue: 'value1' });
expect(hook.result.current.state).toBe('value1');
hook.rerender({ key: 'key2', defaultValue: 'value2' });
expect(hook.result.current.state).toBe('value2');
});
it('should get default and set value for a given key', () => {
const hook = setUp({ key: 'key', defaultValue: 'defaultValue' });
expect(hook.result.current.state).toBe('defaultValue');
act(() => {
hook.result.current.setState('setValue');
});
expect(hook.result.current.state).toBe('setValue');
hook.rerender({ key: 'key' });
expect(hook.result.current.state).toBe('setValue');
});
it('should remove value for a given key', () => {
const hook = setUp({ key: 'key' });
act(() => {
hook.result.current.setState('value');
});
expect(hook.result.current.state).toBe('value');
act(() => {
hook.result.current.setState(undefined);
});
expect(hook.result.current.state).toBeUndefined();
act(() => hook.result.current.setState('value'));
expect(hook.result.current.state).toBe('value');
act(() => hook.result.current.setState());
expect(hook.result.current.state).toBeUndefined();
});
});
|
56 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useAntdTable | petrpan-code/alibaba/hooks/packages/hooks/src/useAntdTable/__tests__/index.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import { sleep } from '../../utils/testingHelpers';
import useAntdTable from '../index';
interface Query {
current: number;
pageSize: number;
[key: string]: any;
}
describe('useAntdTable', () => {
// jest.useFakeTimers();
let queryArgs: any;
const asyncFn = (query: Query, formData: any = {}) => {
queryArgs = { ...query, ...formData };
return Promise.resolve({
total: 20,
list: [],
});
};
let searchType = 'simple';
const form: any = {
getInternalHooks: () => {},
initialValue: {
name: 'default name',
},
fieldsValue: {
name: 'default name',
},
getFieldsValue() {
if (searchType === 'simple') {
return {
name: this.fieldsValue.name,
};
}
return this.fieldsValue;
},
setFieldsValue(values: object) {
this.fieldsValue = {
...this.fieldsValue,
...values,
};
},
resetFields() {
this.fieldsValue = { ...this.initialValue };
},
validateFields(fields) {
const targetFileds = {};
fields.forEach((field) => {
targetFileds[field] = this.fieldsValue[field];
});
return Promise.resolve(targetFileds);
},
};
const changeSearchType = (type: any) => {
searchType = type;
};
const setUp = (service, options) => renderHook((o) => useAntdTable(service, o || options));
let hook: any;
// afterEach(() => {
// form.resetFields();
// changeSearchType('simple');
// hook?.unmount();
// });
it('should fetch after first render', async () => {
queryArgs = undefined;
form.resetFields();
changeSearchType('simple');
act(() => {
hook = setUp(asyncFn, {});
});
expect(hook.result.current.tableProps.loading).toBe(false);
expect(hook.result.current.tableProps.pagination.current).toBe(1);
expect(hook.result.current.tableProps.pagination.pageSize).toBe(10);
await waitFor(() => expect(hook.result.current.tableProps.pagination.total).toBe(20));
});
it('should defaultParams work', async () => {
queryArgs = undefined;
form.resetFields();
changeSearchType('advance');
act(() => {
hook = setUp(asyncFn, {
form,
defaultParams: [
{
current: 2,
pageSize: 10,
},
{ name: 'hello', phone: '123' },
],
defaultType: 'advance',
});
});
const { search } = hook.result.current;
expect(hook.result.current.tableProps.loading).toBe(false);
await waitFor(() => expect(queryArgs.current).toBe(2));
expect(queryArgs.pageSize).toBe(10);
expect(queryArgs.name).toBe('hello');
expect(queryArgs.phone).toBe('123');
expect(search.type).toBe('advance');
});
it('should stop the query when validate fields failed', async () => {
queryArgs = undefined;
form.resetFields();
changeSearchType('advance');
act(() => {
hook = setUp(asyncFn, {
form: { ...form, validateFields: () => Promise.reject() },
defaultParams: [
{
current: 2,
pageSize: 10,
},
{ name: 'hello', phone: '123' },
],
defaultType: 'advance',
});
});
await sleep(1);
expect(queryArgs).toBeUndefined();
});
it('should ready work', async () => {
queryArgs = undefined;
form.resetFields();
changeSearchType('advance');
act(() => {
hook = setUp(asyncFn, {
ready: false,
form,
defaultParams: [
{
current: 2,
pageSize: 10,
},
{ name: 'hello', phone: '123' },
],
defaultType: 'advance',
});
});
await sleep(1);
expect(queryArgs).toBeUndefined();
hook.rerender({
ready: true,
form,
defaultParams: [
{
current: 2,
pageSize: 10,
},
{ name: 'hello', phone: '456' },
],
defaultType: 'advance',
});
const { search } = hook.result.current;
expect(hook.result.current.tableProps.loading).toBe(false);
await waitFor(() => expect(queryArgs.current).toBe(2));
expect(queryArgs.pageSize).toBe(10);
expect(queryArgs.name).toBe('hello');
expect(queryArgs.phone).toBe('456');
expect(search.type).toBe('advance');
});
it('should antd v3 work', async () => {
queryArgs = undefined;
form.resetFields();
changeSearchType('simple');
const v3Form = {
...form,
getInternalHooks: undefined,
validateFields: function (fields, callback) {
const targetFileds = {};
fields.forEach((field) => {
targetFileds[field] = this.fieldsValue[field];
});
callback(undefined, targetFileds);
},
getFieldInstance(key: string) {
// 根据不同的 type 返回不同的 fieldsValues
if (searchType === 'simple') {
return ['name'].includes(key);
}
return ['name', 'email', 'phone'].includes(key);
},
};
act(() => {
hook = setUp(asyncFn, { form: v3Form });
});
const { search } = hook.result.current;
expect(hook.result.current.tableProps.loading).toBe(false);
await waitFor(() => expect(queryArgs.current).toBe(1));
expect(queryArgs.pageSize).toBe(10);
expect(queryArgs.name).toBe('default name');
expect(search.type).toBe('simple');
// /* 切换 分页 */
act(() => {
hook.result.current.tableProps.onChange({
current: 2,
pageSize: 5,
});
});
await waitFor(() => expect(queryArgs.current).toBe(2));
expect(queryArgs.pageSize).toBe(5);
expect(queryArgs.name).toBe('default name');
/* 改变 name， 提交表单 */
v3Form.fieldsValue.name = 'change name';
act(() => {
search.submit();
});
await waitFor(() => expect(queryArgs.current).toBe(1));
expect(queryArgs.current).toBe(1);
// expect(queryArgs.pageSize).toBe(5);
expect(queryArgs.name).toBe('change name');
});
it('should reset pageSize in defaultParams', async () => {
queryArgs = undefined;
form.resetFields();
act(() => {
hook = setUp(asyncFn, {
form,
defaultParams: [
{
current: 1,
pageSize: 10,
},
],
});
});
const { search, tableProps } = hook.result.current;
expect(tableProps.loading).toBe(false);
await waitFor(() => expect(queryArgs.current).toBe(1));
expect(queryArgs.pageSize).toBe(10);
// change params
act(() => {
tableProps.onChange({
current: 2,
pageSize: 5,
});
});
await waitFor(() => {
expect(queryArgs.current).toBe(2);
expect(queryArgs.pageSize).toBe(5);
});
// reset params
act(() => {
search.reset();
});
await waitFor(() => {
expect(queryArgs.current).toBe(1);
expect(queryArgs.pageSize).toBe(10);
});
});
it('should reset pageSize in defaultPageSize', async () => {
queryArgs = undefined;
form.resetFields();
act(() => {
hook = setUp(asyncFn, {
form,
defaultParams: {
current: 1,
pageSize: 10,
},
defaultPageSize: 20,
});
});
const { search, tableProps } = hook.result.current;
expect(tableProps.loading).toBe(false);
await waitFor(() => expect(queryArgs.current).toBe(1));
expect(queryArgs.pageSize).toBe(20);
// change params
act(() => {
tableProps.onChange({
current: 2,
pageSize: 5,
});
});
await waitFor(() => {
expect(queryArgs.current).toBe(2);
expect(queryArgs.pageSize).toBe(5);
});
// reset params
act(() => {
search.reset();
});
await waitFor(() => {
expect(queryArgs.current).toBe(1);
expect(queryArgs.pageSize).toBe(20);
});
});
it('search submit use default params', async () => {
queryArgs = undefined;
form.resetFields();
act(() => {
hook = setUp(asyncFn, {
form,
defaultParams: [
{
current: 2,
pageSize: 100,
},
],
});
});
const { search } = hook.result.current;
act(() => {
search.submit();
});
await waitFor(() => {
expect(queryArgs.current).toBe(2);
expect(queryArgs.pageSize).toBe(100);
});
});
});
|
66 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useAsyncEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useAsyncEffect/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useAsyncEffect from '../index';
import { useState } from 'react';
import { sleep } from '../../utils/testingHelpers';
describe('useAsyncEffect', () => {
it('should work without clean up', async () => {
const hook = renderHook(() => {
const [x, setX] = useState(0);
useAsyncEffect(async () => {
await sleep(100);
setX(1);
}, []);
return x;
});
expect(hook.result.current).toBe(0);
await act(async () => {
await sleep(150);
});
expect(hook.result.current).toBe(1);
});
it('should work with yield break', async () => {
const hook = renderHook(() => {
const [x, setX] = useState(1);
const [y, setY] = useState(0);
useAsyncEffect(
async function* () {
await sleep(100);
yield;
setY(x);
},
[x],
);
return {
y,
setX,
};
});
expect(hook.result.current.y).toBe(0);
await act(async () => {
await sleep(50);
hook.result.current.setX(2);
});
expect(hook.result.current.y).toBe(0);
await act(async () => {
await sleep(20);
});
expect(hook.result.current.y).toBe(0);
await act(async () => {
await sleep(50);
hook.result.current.setX(3);
});
expect(hook.result.current.y).toBe(0);
await act(async () => {
await sleep(80);
});
expect(hook.result.current.y).toBe(0);
await act(async () => {
await sleep(50);
});
expect(hook.result.current.y).toBe(3);
});
});
|
72 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useBoolean | petrpan-code/alibaba/hooks/packages/hooks/src/useBoolean/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useBoolean from '../index';
const setUp = (defaultValue?: boolean) => renderHook(() => useBoolean(defaultValue));
describe('useBoolean', () => {
it('test on methods', async () => {
const { result } = setUp();
expect(result.current[0]).toBe(false);
act(() => {
result.current[1].setTrue();
});
expect(result.current[0]).toBe(true);
act(() => {
result.current[1].setFalse();
});
expect(result.current[0]).toBe(false);
act(() => {
result.current[1].toggle();
});
expect(result.current[0]).toBe(true);
act(() => {
result.current[1].toggle();
});
expect(result.current[0]).toBe(false);
act(() => {
result.current[1].set(false);
});
expect(result.current[0]).toBe(false);
act(() => {
result.current[1].set(true);
});
expect(result.current[0]).toBe(true);
act(() => {
// @ts-ignore
result.current[1].set(0);
});
expect(result.current[0]).toBe(false);
act(() => {
// @ts-ignore
result.current[1].set('a');
});
expect(result.current[0]).toBe(true);
});
it('test on default value', () => {
const hook1 = setUp(true);
expect(hook1.result.current[0]).toBe(true);
const hook2 = setUp();
expect(hook2.result.current[0]).toBe(false);
// @ts-ignore
const hook3 = setUp(0);
expect(hook3.result.current[0]).toBe(false);
// @ts-ignore
const hook4 = setUp('');
expect(hook4.result.current[0]).toBe(false);
// @ts-ignore
const hook5 = setUp('hello');
expect(hook5.result.current[0]).toBe(true);
});
});
|
77 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useClickAway | petrpan-code/alibaba/hooks/packages/hooks/src/useClickAway/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useClickAway from '../index';
describe('useClickAway', () => {
let container: HTMLDivElement;
let container1: HTMLDivElement;
beforeEach(() => {
container = document.createElement('div');
container1 = document.createElement('div');
container1.setAttribute('id', 'ele');
document.body.appendChild(container);
document.body.appendChild(container1);
});
afterEach(() => {
document.body.removeChild(container);
document.body.removeChild(container1);
});
it('test on dom optional', async () => {
let state: number = 0;
const { rerender, unmount } = renderHook((dom: any) =>
useClickAway(() => {
state++;
}, dom),
);
rerender(container);
container.click();
expect(state).toBe(0);
document.body.click();
expect(state).toBe(1);
rerender(container1);
container1.click();
expect(state).toBe(1);
document.body.click();
expect(state).toBe(2);
unmount();
document.body.click();
expect(state).toBe(2);
});
it('should works on multiple target', async () => {
let state: number = 0;
const { rerender, unmount } = renderHook((dom: any) =>
useClickAway(() => {
state++;
}, dom),
);
rerender([container, container1]);
container.click();
expect(state).toBe(0);
container1.click();
expect(state).toBe(0);
document.body.click();
expect(state).toBe(1);
unmount();
document.body.click();
expect(state).toBe(1);
});
});
|
87 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useControllableValue | petrpan-code/alibaba/hooks/packages/hooks/src/useControllableValue/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useControllableValue, { Options, Props } from '../index';
describe('useControllableValue', () => {
const setUp = (props?: Props, options?: Options<any>): any =>
renderHook(() => useControllableValue(props, options));
it('defaultValue should work', () => {
const hook = setUp({ defaultValue: 1 });
expect(hook.result.current[0]).toBe(1);
});
it('value should work', () => {
const hook = setUp({ defaultValue: 1, value: 2 });
expect(hook.result.current[0]).toBe(2);
});
it('state should be undefined', () => {
const hook = setUp();
expect(hook.result.current[0]).toBeUndefined();
});
it('onChange should work', () => {
let extraParam: string = '';
const props = {
value: 2,
onChange(v: any, extra) {
this.value = v;
extraParam = extra;
},
};
const hook = setUp(props);
expect(hook.result.current[0]).toBe(2);
act(() => {
hook.result.current[1](3, 'extraParam');
});
expect(props.value).toBe(3);
expect(extraParam).toBe('extraParam');
});
it('test on state update', () => {
const props: any = {
value: 1,
};
const { result, rerender } = setUp(props);
props.value = 2;
rerender(props);
expect(result.current[0]).toBe(2);
props.value = 3;
rerender(props);
expect(result.current[0]).toBe(3);
});
it('test set state', async () => {
const { result } = setUp({
newValue: 1,
});
const [, setValue] = result.current;
act(() => setValue(undefined));
expect(result.current[0]).toBeUndefined();
act(() => setValue(null));
expect(result.current[0]).toBeNull();
act(() => setValue(55));
expect(result.current[0]).toBe(55);
act(() => setValue((prevState) => prevState + 1));
expect(result.current[0]).toBe(56);
});
it('type inference should work', async () => {
type Value = {
foo: number;
};
const props: {
value: Value;
defaultValue: Value;
onChange: (val: Value) => void;
} = {
value: {
foo: 123,
},
defaultValue: {
foo: 123,
},
onChange: () => {},
};
const hook = renderHook(() => useControllableValue(props));
const [v] = hook.result.current;
expect(v.foo).toBe(123);
});
});
|
94 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useCookieState | petrpan-code/alibaba/hooks/packages/hooks/src/useCookieState/__tests__/index.test.tsx | import { renderHook, act } from '@testing-library/react';
import useCookieState from '../index';
import type { Options } from '../index';
import Cookies from 'js-cookie';
describe('useCookieState', () => {
const setUp = (key: string, options: Options) =>
renderHook(() => {
const [state, setState] = useCookieState(key, options);
return {
state,
setState,
} as const;
});
it('getKey should work', () => {
const COOKIE = 'test-key';
const hook = setUp(COOKIE, {
defaultValue: 'A',
});
expect(hook.result.current.state).toBe('A');
act(() => {
hook.result.current.setState('B');
});
expect(hook.result.current.state).toBe('B');
const anotherHook = setUp(COOKIE, {
defaultValue: 'A',
});
expect(anotherHook.result.current.state).toBe('B');
act(() => {
anotherHook.result.current.setState('C');
});
expect(anotherHook.result.current.state).toBe('C');
expect(hook.result.current.state).toBe('B');
expect(Cookies.get(COOKIE)).toBe('C');
});
it('should support undefined', () => {
const COOKIE = 'test-boolean-key-with-undefined';
const hook = setUp(COOKIE, {
defaultValue: 'undefined',
});
expect(hook.result.current.state).toBe('undefined');
act(() => {
hook.result.current.setState(undefined);
});
expect(hook.result.current.state).toBeUndefined();
const anotherHook = setUp(COOKIE, {
defaultValue: 'false',
});
expect(anotherHook.result.current.state).toBe('false');
expect(Cookies.get(COOKIE)).toBeUndefined();
act(() => {
// @ts-ignore
hook.result.current.setState();
});
expect(hook.result.current.state).toBeUndefined();
expect(Cookies.get(COOKIE)).toBeUndefined();
});
it('should support empty string', () => {
Cookies.set('test-key-empty-string', '');
expect(Cookies.get('test-key-empty-string')).toBe('');
const COOKIE = 'test-key-empty-string';
const hook = setUp(COOKIE, {
defaultValue: 'hello',
});
expect(hook.result.current.state).toBe('');
});
it('should support function updater', () => {
const COOKIE = 'test-func-updater';
const hook = setUp(COOKIE, {
defaultValue: () => 'hello world',
});
expect(hook.result.current.state).toBe('hello world');
act(() => {
hook.result.current.setState((state) => `${state}, zhangsan`);
});
expect(hook.result.current.state).toBe('hello world, zhangsan');
});
it('using the same cookie name', () => {
const COOKIE_NAME = 'test-same-cookie-name';
const { result: result1 } = setUp(COOKIE_NAME, { defaultValue: 'A' });
const { result: result2 } = setUp(COOKIE_NAME, { defaultValue: 'B' });
expect(result1.current.state).toBe('A');
expect(result2.current.state).toBe('B');
act(() => {
result1.current.setState('C');
});
expect(result1.current.state).toBe('C');
expect(result2.current.state).toBe('B');
expect(Cookies.get(COOKIE_NAME)).toBe('C');
act(() => {
result2.current.setState('D');
});
expect(result1.current.state).toBe('C');
expect(result2.current.state).toBe('D');
expect(Cookies.get(COOKIE_NAME)).toBe('D');
});
});
|
101 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useCountDown | petrpan-code/alibaba/hooks/packages/hooks/src/useCountDown/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useCountDown, { Options } from '../index';
const setup = (options: Options = {}) =>
renderHook((props: Options = options) => useCountDown(props));
describe('useCountDown', () => {
beforeAll(() => {
jest.useFakeTimers({ legacyFakeTimers: false });
jest.setSystemTime(1479427200000);
});
afterAll(() => {
jest.useRealTimers();
});
it('should initialize correctly with undefined targetDate', () => {
const { result } = setup();
const [count, formattedRes] = result.current;
expect(count).toBe(0);
expect(formattedRes).toEqual({
days: 0,
hours: 0,
minutes: 0,
seconds: 0,
milliseconds: 0,
});
});
it('should initialize correctly with correct targetDate', () => {
const { result } = setup({
targetDate: Date.now() + 5000,
interval: 1000,
});
const [count, formattedRes] = result.current;
expect(count).toBe(5000);
expect(formattedRes.seconds).toBe(5);
expect(formattedRes.milliseconds).toBe(0);
});
it('should work manually', () => {
const { result, rerender } = setup({ interval: 100 });
rerender({ targetDate: Date.now() + 5000, interval: 1000 });
expect(result.current[0]).toBe(5000);
expect(result.current[1].seconds).toBe(5);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(4000);
expect(result.current[1].seconds).toBe(4);
act(() => {
jest.advanceTimersByTime(4000);
});
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
});
it('should work automatically', () => {
const { result } = setup({
targetDate: Date.now() + 5000,
interval: 1000,
});
expect(result.current[0]).toBe(5000);
expect(result.current[1].seconds).toBe(5);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(4000);
expect(result.current[1].seconds).toBe(4);
act(() => {
jest.advanceTimersByTime(4000);
});
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
});
it('should work stop', () => {
const { result, rerender } = setup({
targetDate: Date.now() + 5000,
interval: 1000,
});
rerender({
targetDate: Date.now() + 5000,
interval: 1000,
});
expect(result.current[0]).toBe(5000);
expect(result.current[1].seconds).toBe(5);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(4000);
expect(result.current[1].seconds).toBe(4);
rerender({
targetDate: undefined,
});
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
});
it('it onEnd should work', () => {
const onEnd = jest.fn();
setup({
targetDate: Date.now() + 5000,
interval: 1000,
onEnd,
});
act(() => {
jest.advanceTimersByTime(6000);
});
expect(onEnd).toBeCalled();
});
it('timeLeft should be 0 when target date less than current time', () => {
const { result } = setup({
targetDate: Date.now() - 5000,
});
expect(result.current[0]).toBe(0);
});
it('should initialize correctly with undefined leftTime', () => {
const { result } = setup();
const [count, formattedRes] = result.current;
expect(count).toBe(0);
expect(formattedRes).toEqual({
days: 0,
hours: 0,
minutes: 0,
seconds: 0,
milliseconds: 0,
});
});
it('should initialize correctly with correct leftTime', () => {
const { result } = setup({ leftTime: 5 * 1000, interval: 1000 });
const [count, formattedRes] = result.current;
expect(count).toBe(5000);
expect(formattedRes.seconds).toBe(5);
expect(formattedRes.milliseconds).toBe(0);
});
it('should work manually', () => {
const { result, rerender } = setup({ interval: 100 });
rerender({ leftTime: 5 * 1000, interval: 1000 });
expect(result.current[0]).toBe(5000);
expect(result.current[1].seconds).toBe(5);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(4000);
expect(result.current[1].seconds).toBe(4);
act(() => {
jest.advanceTimersByTime(4000);
});
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
});
it('should work automatically', () => {
const { result } = setup({ leftTime: 5 * 1000, interval: 1000 });
expect(result.current[0]).toBe(5000);
expect(result.current[1].seconds).toBe(5);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(4000);
expect(result.current[1].seconds).toBe(4);
act(() => {
jest.advanceTimersByTime(4000);
});
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
});
it('should work stop', () => {
const { result, rerender } = setup({ leftTime: 5 * 1000, interval: 1000 });
rerender({ leftTime: 5 * 1000, interval: 1000 });
expect(result.current[0]).toBe(5000);
expect(result.current[1].seconds).toBe(5);
act(() => {
jest.advanceTimersByTime(1000);
});
expect(result.current[0]).toBe(4000);
expect(result.current[1].seconds).toBe(4);
rerender({ leftTime: undefined });
expect(result.current[0]).toBe(0);
expect(result.current[1].seconds).toBe(0);
});
it('it onEnd should work', () => {
const onEnd = jest.fn();
setup({ leftTime: 5 * 1000, interval: 1000, onEnd });
act(() => {
jest.advanceTimersByTime(6000);
});
expect(onEnd).toBeCalled();
});
it('timeLeft should be 0 when leftTime less than current time', () => {
const { result } = setup({ leftTime: -5 * 1000 });
expect(result.current[0]).toBe(0);
});
});
|
108 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useCounter | petrpan-code/alibaba/hooks/packages/hooks/src/useCounter/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useCounter, { Options } from '../index';
const setUp = (init?: number, options?: Options) => renderHook(() => useCounter(init, options));
it('should init counter', () => {
const { result } = setUp(100);
const [current] = result.current;
expect(current).toBe(100);
});
it('should max, min, actions work', () => {
const { result } = setUp(100, { max: 10, min: 1 });
const [current, { inc, dec, reset, set }] = result.current;
expect(current).toBe(10);
act(() => {
inc(1);
});
expect(result.current[0]).toBe(10);
act(() => {
dec(100);
});
expect(result.current[0]).toBe(1);
act(() => {
inc();
});
expect(result.current[0]).toBe(2);
act(() => {
reset();
});
expect(result.current[0]).toBe(10);
act(() => {
set(-1000);
});
expect(result.current[0]).toBe(1);
act(() => {
set((c) => c + 2);
});
expect(result.current[0]).toBe(3);
act(() => {
inc();
inc();
inc();
});
expect(result.current[0]).toBe(6);
});
|
113 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useCreation | petrpan-code/alibaba/hooks/packages/hooks/src/useCreation/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import { useState } from 'react';
import useCreation from '../index';
describe('useCreation', () => {
class Foo {
constructor() {
this.data = Math.random();
}
data: number;
}
const setUp = (): any =>
renderHook(() => {
const [count, setCount] = useState(0);
const [, setFlag] = useState({});
const foo = useCreation(() => new Foo(), [count]);
return {
foo,
setCount,
count,
setFlag,
};
});
it('should work', () => {
const hook = setUp();
const { foo } = hook.result.current;
act(() => {
hook.result.current.setFlag({});
});
expect(hook.result.current.foo).toBe(foo);
act(() => {
hook.result.current.setCount(1);
});
expect(hook.result.current.foo).not.toBe(foo);
});
});
|
119 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDebounce | petrpan-code/alibaba/hooks/packages/hooks/src/useDebounce/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useDebounce from '../index';
import { sleep } from '../../utils/testingHelpers';
describe('useDebounce', () => {
it('useDebounce wait:200ms', async () => {
let mountedState = 0;
const { result, rerender } = renderHook(() => useDebounce(mountedState, { wait: 200 }));
expect(result.current).toBe(0);
mountedState = 1;
rerender();
await sleep(50);
expect(result.current).toBe(0);
mountedState = 2;
rerender();
await sleep(100);
expect(result.current).toBe(0);
mountedState = 3;
rerender();
await sleep(150);
expect(result.current).toBe(0);
mountedState = 4;
rerender();
await act(async () => {
await sleep(250);
});
expect(result.current).toBe(4);
});
});
|
124 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDebounceEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useDebounceEffect/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useDebounceEffect from '../index';
import { sleep } from '../../utils/testingHelpers';
let hook;
describe('useDebounceEffect', () => {
it('useDebounceEffect should work', async () => {
let mountedState = 1;
const mockEffect = jest.fn(() => {});
const mockCleanUp = jest.fn(() => {});
act(() => {
hook = renderHook(() =>
useDebounceEffect(
() => {
mockEffect();
return () => {
mockCleanUp();
};
},
[mountedState],
{ wait: 200 },
),
);
});
expect(mockEffect.mock.calls.length).toBe(0);
expect(mockCleanUp.mock.calls.length).toBe(0);
mountedState = 2;
hook.rerender();
await sleep(50);
mountedState = 3;
hook.rerender();
expect(mockEffect.mock.calls.length).toBe(0);
expect(mockCleanUp.mock.calls.length).toBe(0);
await act(async () => {
await sleep(300);
});
expect(mockEffect.mock.calls.length).toBe(1);
expect(mockCleanUp.mock.calls.length).toBe(0);
mountedState = 4;
hook.rerender();
expect(mockEffect.mock.calls.length).toBe(1);
expect(mockCleanUp.mock.calls.length).toBe(0);
await act(async () => {
await sleep(300);
});
expect(mockEffect.mock.calls.length).toBe(2);
expect(mockCleanUp.mock.calls.length).toBe(1);
});
it('should cancel timeout on unmount', async () => {
const mockEffect = jest.fn(() => {});
const mockCleanUp = jest.fn(() => {});
const hook = renderHook(
(props) =>
useDebounceEffect(
() => {
mockEffect();
return () => {
mockCleanUp();
};
},
[props],
{ wait: 200 },
),
{ initialProps: 0 },
);
expect(mockEffect.mock.calls.length).toBe(0);
expect(mockCleanUp.mock.calls.length).toBe(0);
hook.rerender(1);
await sleep(50);
expect(mockEffect.mock.calls.length).toBe(0);
expect(mockCleanUp.mock.calls.length).toBe(0);
await act(async () => {
await sleep(300);
});
expect(mockEffect.mock.calls.length).toBe(1);
expect(mockCleanUp.mock.calls.length).toBe(0);
hook.rerender(2);
await act(async () => {
await sleep(300);
});
expect(mockEffect.mock.calls.length).toBe(2);
expect(mockCleanUp.mock.calls.length).toBe(1);
hook.unmount();
expect(mockEffect.mock.calls.length).toBe(2);
expect(mockCleanUp.mock.calls.length).toBe(2);
});
});
|
129 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDebounceFn | petrpan-code/alibaba/hooks/packages/hooks/src/useDebounceFn/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import { sleep } from '../../utils/testingHelpers';
import useDebounceFn from '../index';
interface ParamsObj {
fn: (...arg: any) => any;
deps?: any[];
wait: number;
}
let count = 0;
const debounceFn = (gap: number) => {
count += gap;
};
const setUp = ({ fn, wait }: ParamsObj) => renderHook(() => useDebounceFn(fn, { wait }));
let hook;
describe('useDebounceFn', () => {
it('run, cancel and flush should work', async () => {
act(() => {
hook = setUp({
fn: debounceFn,
wait: 200,
});
});
await act(async () => {
hook.result.current.run(2);
hook.result.current.run(2);
hook.result.current.run(2);
hook.result.current.run(2);
expect(count).toBe(0);
await sleep(300);
expect(count).toBe(2);
hook.result.current.run(4);
expect(count).toBe(2);
await sleep(300);
expect(count).toBe(6);
hook.result.current.run(4);
expect(count).toBe(6);
hook.result.current.cancel();
expect(count).toBe(6);
await sleep(300);
expect(count).toBe(6);
hook.result.current.run(1);
expect(count).toBe(6);
hook.result.current.flush();
expect(count).toBe(7);
await sleep(300);
expect(count).toBe(7);
});
});
// it('should output error when fn is not a function', () => {
// const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
// renderHook(() => useDebounceFn(1 as any));
// expect(errSpy).toBeCalledWith('useDebounceFn expected parameter is a function, got number');
// errSpy.mockRestore();
// });
});
|
134 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDeepCompareEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useDeepCompareEffect/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import { useState } from 'react';
import useDeepCompareEffect from '../index';
describe('useDeepCompareEffect', () => {
it('test deep compare', async () => {
const hook = renderHook(() => {
const [x, setX] = useState(0);
const [y, setY] = useState({});
useDeepCompareEffect(() => {
setX((x) => x + 1);
}, [y]);
return { x, setY };
});
expect(hook.result.current.x).toBe(1);
await act(async () => {
hook.result.current.setY({});
});
expect(hook.result.current.x).toBe(1);
});
});
|
139 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDeepCompareLayoutEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useDeepCompareLayoutEffect/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import { useState } from 'react';
import useDeepCompareLayoutEffect from '../index';
describe('useDeepCompareLayoutEffect', () => {
it('test deep compare', async () => {
const hook = renderHook(() => {
const [x, setX] = useState(0);
const [y, setY] = useState({});
useDeepCompareLayoutEffect(() => {
setX((x) => x + 1);
}, [y]);
return { x, setY };
});
expect(hook.result.current.x).toBe(1);
await act(async () => {
hook.result.current.setY({});
});
expect(hook.result.current.x).toBe(1);
});
});
|
144 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDocumentVisibility | petrpan-code/alibaba/hooks/packages/hooks/src/useDocumentVisibility/__tests__/index.test.ts | import useDocumentVisibility from '../index';
import { renderHook, act } from '@testing-library/react';
const mockIsBrowser = jest.fn();
const mockDocumentVisibilityState = jest.spyOn(document, 'visibilityState', 'get');
jest.mock('../../utils/isBrowser', () => {
return {
__esModule: true,
get default() {
return mockIsBrowser();
},
};
});
afterAll(() => {
jest.clearAllMocks();
});
describe('useDocumentVisibility', () => {
it('isBrowser effect corrent', async () => {
mockDocumentVisibilityState.mockReturnValue('hidden');
// Object.defineProperty(document, 'visibilityState', { value: 'hidden', writable: true });
mockIsBrowser.mockReturnValue(false);
const { result } = renderHook(() => useDocumentVisibility());
expect(result.current).toBe('visible');
});
it('visibilitychange update correct ', async () => {
mockDocumentVisibilityState.mockReturnValue('hidden');
// Object.defineProperty(document, 'visibilityState', { value: 'hidden', writable: true });
mockIsBrowser.mockReturnValue(true);
const { result } = renderHook(() => useDocumentVisibility());
expect(result.current).toBe('hidden');
mockDocumentVisibilityState.mockReturnValue('visible');
// Object.defineProperty(document, 'visibilityState', { value: 'visible', writable: true });
act(() => {
document.dispatchEvent(new Event('visibilitychange'));
});
expect(result.current).toBe('visible');
});
});
|
147 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDrag | petrpan-code/alibaba/hooks/packages/hooks/src/useDrag/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import type { Options } from '../index';
import useDrag from '../index';
import type { BasicTarget } from '../../utils/domTarget';
const setup = <T>(data: T, target: BasicTarget, options?: Options) =>
renderHook((newData: T) => useDrag(newData ? newData : data, target, options));
const events: Record<string, (event: any) => void> = {};
const mockTarget = {
addEventListener: jest.fn((event, callback) => {
events[event] = callback;
}),
removeEventListener: jest.fn((event) => {
Reflect.deleteProperty(events, event);
}),
setAttribute: jest.fn(),
};
describe('useDrag', () => {
it('should add/remove listener on mount/unmount', () => {
const { unmount } = setup(1, mockTarget as any);
expect(mockTarget.addEventListener).toBeCalled();
expect(mockTarget.addEventListener.mock.calls[0][0]).toBe('dragstart');
expect(mockTarget.addEventListener.mock.calls[1][0]).toBe('dragend');
expect(mockTarget.setAttribute).toBeCalledWith('draggable', 'true');
unmount();
expect(mockTarget.removeEventListener).toBeCalled();
});
it('should triggle drag callback', () => {
const onDragStart = jest.fn();
const onDragEnd = jest.fn();
const mockEvent = {
dataTransfer: {
setData: jest.fn(),
},
};
const hook = setup(1, mockTarget as any, {
onDragStart,
onDragEnd,
});
events.dragstart(mockEvent);
expect(onDragStart).toBeCalled();
expect(mockEvent.dataTransfer.setData).toBeCalledWith('custom', '1');
events.dragend(mockEvent);
expect(onDragEnd).toBeCalled();
hook.rerender(2);
events.dragstart(mockEvent);
expect(onDragStart).toBeCalled();
expect(mockEvent.dataTransfer.setData).toHaveBeenLastCalledWith('custom', '2');
events.dragend(mockEvent);
expect(onDragEnd).toBeCalled();
});
it(`should not work when target don't support addEventListener method`, () => {
Object.defineProperty(mockTarget, 'addEventListener', {
get() {
return false;
},
});
setup(1, mockTarget as any);
expect(mockTarget.setAttribute).not.toBeCalled();
});
});
|
151 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDrop | petrpan-code/alibaba/hooks/packages/hooks/src/useDrop/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useDrop, { Options } from '../index';
import type { BasicTarget } from '../../utils/domTarget';
const setup = (target: unknown, options?: Options) =>
renderHook(() => useDrop(target as BasicTarget, options));
const events = {};
const mockTarget = {
addEventListener: jest.fn((event, callback) => {
events[event] = callback;
}),
removeEventListener: jest.fn((event) => {
Reflect.deleteProperty(events, event);
}),
};
const mockEvent = {
dataTransfer: {
getData: (format?: string) => 'mock' as unknown,
get items() {
return [] as unknown[];
},
get files() {
return [] as unknown[];
},
},
clipboardData: {
getData: (format?: string) => 'mock' as unknown,
get items() {
return [] as unknown[];
},
get files() {
return [] as unknown[];
},
},
preventDefault: jest.fn(),
stopPropagation: jest.fn(),
};
describe('useDrop', () => {
it(`should not work when target don't support addEventListener method`, () => {
const originAddEventListener = mockTarget.addEventListener;
Object.defineProperty(mockTarget, 'addEventListener', {
value: false,
});
setup(mockTarget);
expect(Object.keys(events)).toHaveLength(0);
Object.defineProperty(mockTarget, 'addEventListener', {
value: originAddEventListener,
});
});
it('should add/remove listener on mount/unmount', () => {
const { unmount } = setup(mockTarget);
const eventNames = ['dragenter', 'dragover', 'dragleave', 'drop', 'paste'];
expect(mockTarget.addEventListener).toBeCalledTimes(eventNames.length);
eventNames.forEach((eventName, i) => {
expect(mockTarget.addEventListener.mock.calls[i][0]).toBe(eventName);
});
unmount();
expect(mockTarget.removeEventListener).toBeCalledTimes(eventNames.length);
eventNames.forEach((eventName, i) => {
expect(mockTarget.addEventListener.mock.calls[i][0]).toBe(eventName);
});
});
it('should call callback', () => {
const onDragEnter = jest.fn();
const onDragOver = jest.fn();
const onDragLeave = jest.fn();
const onDrop = jest.fn();
const onPaste = jest.fn();
setup(mockTarget, {
onDragEnter,
onDragOver,
onDragLeave,
onDrop,
onPaste,
});
const callbacks = [onDragEnter, onDragOver, onDragLeave, onDrop, onPaste];
const eventNames = ['dragenter', 'dragover', 'dragleave', 'drop', 'paste'];
eventNames.forEach((event) => {
events[event](mockEvent);
});
callbacks.forEach((callback) => expect(callback).toBeCalled());
});
it('should call onText on drop', async () => {
jest.spyOn(mockEvent.dataTransfer, 'items', 'get').mockReturnValue([
{
getAsString: (callback) => {
callback('drop text');
},
},
]);
const onText = jest.fn();
setup(mockTarget, {
onText,
});
events['dragenter'](mockEvent);
events['drop'](mockEvent);
expect(onText.mock.calls[0][0]).toBe('drop text');
});
it('should call onFiles on drop', async () => {
const file = new File(['hello'], 'hello.png');
jest.spyOn(mockEvent.dataTransfer, 'files', 'get').mockReturnValue([file]);
const onFiles = jest.fn();
setup(mockTarget, {
onFiles,
});
events['dragenter'](mockEvent);
events['drop'](mockEvent);
expect(onFiles.mock.calls[0][0]).toHaveLength(1);
});
it('should call onUri on drop', async () => {
const url = 'https://alipay.com';
jest.spyOn(mockEvent.dataTransfer, 'getData').mockImplementation((format: string) => {
if (format === 'text/uri-list') return url;
});
const onUri = jest.fn();
setup(mockTarget, {
onUri,
});
events['dragenter'](mockEvent);
events['drop'](mockEvent);
expect(onUri.mock.calls[0][0]).toBe(url);
});
it('should call onDom on drop', async () => {
const data = {
value: 'mock',
};
jest.spyOn(mockEvent.dataTransfer, 'getData').mockImplementation((format: string) => {
if (format === 'custom') return data;
});
const onDom = jest.fn();
setup(mockTarget, {
onDom,
});
events['dragenter'](mockEvent);
events['drop'](mockEvent);
expect(onDom.mock.calls[0][0]).toMatchObject(data);
// catch JSON.parse error
jest.spyOn(mockEvent.dataTransfer, 'getData').mockImplementation((format: string) => {
if (format === 'custom') return {};
});
events['dragenter'](mockEvent);
events['drop'](mockEvent);
expect(onDom.mock.calls[0][0]).toMatchObject({});
});
it('should call onText on paste', async () => {
jest.spyOn(mockEvent.clipboardData, 'items', 'get').mockReturnValue([
{
getAsString: (callback) => {
callback('paste text');
},
},
]);
const onText = jest.fn();
setup(mockTarget, {
onText,
});
events['dragenter'](mockEvent);
events['paste'](mockEvent);
expect(onText.mock.calls[0][0]).toBe('paste text');
});
});
|
157 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useDynamicList | petrpan-code/alibaba/hooks/packages/hooks/src/useDynamicList/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useDynamicList from '../index';
describe('useDynamicList', () => {
const setUp = (props: any): any => renderHook(() => useDynamicList(props));
it('getKey should work', () => {
const hook = setUp([1, 2, 3]);
expect(hook.result.current.list[0]).toBe(1);
expect(hook.result.current.getKey(0)).toBe(0);
expect(hook.result.current.getKey(1)).toBe(1);
expect(hook.result.current.getKey(2)).toBe(2);
});
it('methods should work', () => {
const hook = setUp([
{ name: 'aaa', age: 18 },
{ name: 'bbb', age: 19 },
{ name: 'ccc', age: 20 },
]);
expect(hook.result.current.list[0].age).toBe(18);
expect(hook.result.current.list[1].age).toBe(19);
expect(hook.result.current.list[2].age).toBe(20);
expect(hook.result.current.getKey(0)).toBe(0);
expect(hook.result.current.getKey(1)).toBe(1);
expect(hook.result.current.getKey(2)).toBe(2);
// unshift
act(() => {
hook.result.current.unshift({ name: 'ddd', age: 21 });
});
expect(hook.result.current.list[0].name).toBe('ddd');
expect(hook.result.current.getKey(0)).toBe(3);
// push
act(() => {
hook.result.current.push({ name: 'ddd', age: 21 });
});
expect(hook.result.current.list[4].name).toBe('ddd');
expect(hook.result.current.getKey(0)).toBe(3);
expect(hook.result.current.getKey(4)).toBe(4);
// insert
act(() => {
hook.result.current.insert(1, { name: 'eee', age: 22 });
});
expect(hook.result.current.list[1].name).toBe('eee');
expect(hook.result.current.getKey(1)).toBe(5);
// merge
act(() => {
hook.result.current.merge(0, [1, 2, 3, 4]);
});
expect(hook.result.current.list[0]).toBe(1);
expect(hook.result.current.getKey(0)).toBe(6);
// move
act(() => {
hook.result.current.move(0, 1);
});
expect(hook.result.current.list[0]).toBe(2);
expect(hook.result.current.getKey(0)).toBe(7);
// move without changes
act(() => {
hook.result.current.move(2, 2);
});
expect(hook.result.current.list[0]).toBe(2);
expect(hook.result.current.getKey(0)).toBe(7);
// shift
act(() => {
hook.result.current.shift();
});
expect(hook.result.current.list[0]).toBe(1);
expect(hook.result.current.getKey(0)).toBe(6);
expect(hook.result.current.list.length).toBe(9);
// pop
act(() => {
hook.result.current.pop();
});
expect(hook.result.current.list.length).toBe(8);
// replace
act(() => {
hook.result.current.replace(7, { value: 8 });
});
expect(hook.result.current.list[7].value).toBe(8);
// remove
act(() => {
hook.result.current.remove(7);
});
expect(hook.result.current.list.length).toBe(7);
});
it('same items should have different keys', () => {
const hook = setUp([1, 1, 1, 1]);
expect(hook.result.current.getKey(0)).toBe(0);
expect(hook.result.current.getKey(1)).toBe(1);
expect(hook.result.current.getKey(2)).toBe(2);
expect(hook.result.current.getKey(3)).toBe(3);
act(() => {
hook.result.current.push(1);
});
expect(hook.result.current.getKey(4)).toBe(4);
const testObj = {};
act(() => {
hook.result.current.push({});
hook.result.current.push(testObj);
hook.result.current.push(testObj);
});
expect(hook.result.current.getKey(5)).toBe(5);
expect(hook.result.current.getKey(6)).toBe(6);
expect(hook.result.current.getKey(7)).toBe(7);
});
it('initialValue changes', () => {
const hook = renderHook(({ initialValue }) => useDynamicList(initialValue), {
initialProps: {
initialValue: [1],
},
});
expect(hook.result.current.list[0]).toBe(1);
expect(hook.result.current.getKey(0)).toBe(0);
act(() => {
hook.result.current.resetList([2]);
});
expect(hook.result.current.list[0]).toBe(2);
expect(hook.result.current.getKey(0)).toBe(1);
act(() => {
hook.result.current.resetList([3]);
});
expect(hook.result.current.list[0]).toBe(3);
expect(hook.result.current.getKey(0)).toBe(2);
});
it('sortList', () => {
const hook = setUp([1, 2, 3, 4]);
const formData = [
{
name: 'my bro',
age: '23',
memo: "he's my bro",
},
{
name: 'my sis',
age: '21',
memo: "she's my sis",
},
null,
{
name: '新增行',
age: '25',
},
];
let sorted = hook.result.current.sortList(formData);
expect(sorted.length).toBe(3);
expect(sorted[0].name).toBe('my bro');
act(() => {
hook.result.current.move(3, 0);
});
sorted = hook.result.current.sortList(formData);
expect(sorted[0].name).toBe('新增行');
});
});
|
165 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useEventEmitter | petrpan-code/alibaba/hooks/packages/hooks/src/useEventEmitter/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import { useState } from 'react';
import useEventEmitter from '../index';
describe('useEventEmitter', () => {
const setUp = (): any =>
renderHook(() => {
const event$ = useEventEmitter<number>();
const [count, setCount] = useState(0);
event$.useSubscription((val) => {
setCount((c) => c + val);
});
event$.useSubscription((val) => {
setCount((c) => c + val + 10);
});
return {
event$,
count,
};
});
it('emit and subscribe should work', () => {
const hook = setUp();
act(() => {
hook.result.current.event$.emit(1);
});
expect(hook.result.current.count).toBe(12);
act(() => {
hook.result.current.event$.emit(2);
});
expect(hook.result.current.count).toBe(26);
});
});
|
170 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useEventListener | petrpan-code/alibaba/hooks/packages/hooks/src/useEventListener/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useEventListener from '../index';
describe('useEventListener', () => {
let container: HTMLDivElement;
beforeEach(() => {
container = document.createElement('div');
document.body.appendChild(container);
});
afterEach(() => {
document.body.removeChild(container);
});
it('test on click listener', async () => {
let state: number = 0;
const onClick = () => {
state++;
};
const { rerender, unmount } = renderHook(() =>
useEventListener('click', onClick, { target: () => container }),
);
document.body.click();
expect(state).toBe(0);
rerender();
container.click();
expect(state).toBe(1);
unmount();
document.body.click();
expect(state).toBe(1);
});
});
|
176 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useEventTarget | petrpan-code/alibaba/hooks/packages/hooks/src/useEventTarget/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useEventTarget from '../index';
describe('useEventTarget', () => {
it('should work without initial value', async () => {
const hook = renderHook(() => useEventTarget());
expect(hook.result.current[0]).toBeUndefined();
act(() => {
hook.result.current[1].onChange({ target: { value: 'abc' } });
});
expect(hook.result.current[0]).toBe('abc');
});
it('should work with initial value', async () => {
const hook = renderHook(() => useEventTarget({ initialValue: 'abc' }));
expect(hook.result.current[0]).toBe('abc');
act(() => {
hook.result.current[1].onChange({ target: { value: 'def' } });
});
expect(hook.result.current[0]).toBe('def');
act(() => {
hook.result.current[1].reset();
});
expect(hook.result.current[0]).toBe('abc');
});
it('should work with transformer', () => {
const hook = renderHook(() =>
useEventTarget({
transformer: (str: string) => str.toUpperCase(),
}),
);
expect(hook.result.current[0]).toBeUndefined();
act(() => {
hook.result.current[1].onChange({ target: { value: 'def' } });
});
expect(hook.result.current[0]).toBe('DEF');
});
it('should be able to transform to any type', () => {
const hook = renderHook(() =>
useEventTarget<string, number>({
transformer: (num: number) => String(num),
}),
);
expect(hook.result.current[0]).toBeUndefined();
act(() => {
hook.result.current[1].onChange({ target: { value: 123 } });
});
expect(hook.result.current[0]).toBe('123');
});
});
|
182 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useExternal | petrpan-code/alibaba/hooks/packages/hooks/src/useExternal/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useExternal, { Options } from '../index';
import { fireEvent } from '@testing-library/react';
const setup = (path: string, options?: Options) => renderHook(() => useExternal(path, options));
describe('useExternal', () => {
beforeEach(() => {
document.body.innerHTML = '';
document.head.innerHTML = '';
});
it('should load a script', () => {
const path = 'https://ahooks.js.org/useExternal/test-external-script.js';
const { result } = setup(path, {
js: {
async: true,
},
});
const script = document.querySelector('script') as HTMLScriptElement;
expect(result.current).toBe('loading');
act(() => {
fireEvent.load(script);
});
expect(result.current).toBe('ready');
});
it('should load a css', () => {
const path = 'https://ahooks.js.org/useExternal/bootstrap-badge.css';
const { result } = setup(path, {
css: {
media: 'all',
},
});
const link = document.querySelector('link') as HTMLLinkElement;
expect(result.current).toBe('loading');
act(() => {
fireEvent.load(link);
});
expect(result.current).toBe('ready');
});
it('status should be unset without path', () => {
const { result } = setup('');
expect(result.current).toBe('unset');
});
it('status should be error when load failed', async () => {
const { result } = setup('xx.js');
const script = document.querySelector('script') as HTMLScriptElement;
act(() => {
fireEvent.error(script);
});
expect(result.current).toBe('error');
});
it('should throw error when provide unsupported type', () => {
const mockSpy = jest.spyOn(console, 'error').mockImplementationOnce(() => {});
setup('ahooks.ts');
expect(mockSpy).toBeCalled();
});
it('should not load again when the js exists', () => {
const path = 'a.js';
const hook1 = setup(path);
const script = document.querySelector('script') as HTMLScriptElement;
act(() => {
fireEvent.load(script);
});
expect(hook1.result.current).toBe('ready');
const hook2 = setup(path);
expect(hook2.result.current).toBe('ready');
});
it('should not load again when the css exists', () => {
const path = 'a.css';
const hook1 = setup(path);
const link = document.querySelector('link') as HTMLLinkElement;
act(() => {
fireEvent.load(link);
});
expect(hook1.result.current).toBe('ready');
const hook2 = setup(path);
expect(hook2.result.current).toBe('ready');
});
it('should remove when not use', () => {
const { unmount } = setup('b.js');
const script = document.querySelector('script') as HTMLScriptElement;
act(() => {
fireEvent.load(script);
});
unmount();
expect(document.querySelector('script')).toBeNull();
});
it('should not remove when keepWhenUnused is true', () => {
// https://github.com/alibaba/hooks/discussions/2163
const { result, unmount } = setup('b.js', {
keepWhenUnused: true,
});
const script = document.querySelector('script') as HTMLScriptElement;
act(() => {
fireEvent.load(script);
});
unmount();
expect(result.current).toBe('ready');
});
it('css preload should work in IE Edge', () => {
Object.defineProperty(HTMLLinkElement.prototype, 'hideFocus', {
value: true,
});
setup('b.css');
const link = document.querySelector('link') as HTMLLinkElement;
act(() => {
fireEvent.load(link);
});
expect(link.rel).toBe('preload');
expect(link.as).toBe('style');
});
});
|
189 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useFavicon | petrpan-code/alibaba/hooks/packages/hooks/src/useFavicon/__tests__/index.test.tsx | import { renderHook } from '@testing-library/react';
import useFavicon from '../index';
describe('useFavicon', () => {
it('should set the favicon', () => {
expect(document.querySelector("link[rel*='icon']")).toBeNull();
renderHook(() => useFavicon('favicon.ico'));
expect(document.querySelector("link[rel*='icon']")).not.toBeNull();
});
it('should support svg/png/ico/gif', () => {
const { rerender } = renderHook((url: string) => useFavicon(url));
const suffixs = ['svg', 'png', 'ico', 'gif'];
const imgTypeMap = {
svg: 'image/svg+xml',
ico: 'image/x-icon',
gif: 'image/gif',
png: 'image/png',
};
suffixs.forEach((suffix) => {
const url = `favicon.${suffix}`;
rerender(url);
const link = document.querySelector("link[rel*='icon']") as HTMLLinkElement;
expect(link).toHaveAttribute('type', imgTypeMap[suffix]);
expect(link).toHaveAttribute('href', url);
expect(link).toHaveAttribute('rel', 'shortcut icon');
});
});
});
|
194 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useFocusWithin | petrpan-code/alibaba/hooks/packages/hooks/src/useFocusWithin/__tests__/index.test.tsx | import React, { useRef } from 'react';
import useFocusWithin, { Options } from '../index';
import { render, fireEvent } from '@testing-library/react';
const setup = (options?: Options) => {
const TestComponent = () => {
const ref = useRef(null);
const isFocusWithin = useFocusWithin(ref, options);
return (
<div ref={ref}>
<label>
First Name
<input />
</label>
<label>
Last Name
<input />
</label>
<p>isFocusWithin: {JSON.stringify(isFocusWithin)}</p>
</div>
);
};
return render(<TestComponent />);
};
describe('useFocusWithin', () => {
it('should call onFocus/onBlur', () => {
const onFocus = jest.fn();
const onBlur = jest.fn();
const result = setup({ onFocus, onBlur });
fireEvent.focusIn(result.getByLabelText('First Name'));
expect(onFocus).toBeCalled();
fireEvent.focusOut(result.getByLabelText('First Name'));
expect(onBlur).toBeCalled();
});
it('should call onChange', () => {
const onChange = jest.fn();
const result = setup({ onChange });
fireEvent.focusIn(result.getByLabelText('First Name'));
expect(onChange).toBeCalledWith(true);
fireEvent.focusOut(result.getByLabelText('First Name'));
expect(onChange).toHaveBeenLastCalledWith(false);
});
});
|
200 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useFullscreen | petrpan-code/alibaba/hooks/packages/hooks/src/useFullscreen/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useFullscreen from '../index';
import type { Options } from '../index';
import type { BasicTarget } from '../../utils/domTarget';
let globalHook: any;
let targetEl: any;
const events = {
fullscreenchange: new Set(),
fullscreenerror: new Set(),
};
const setup = (target: BasicTarget, options?: Options) => {
globalHook = renderHook(() => useFullscreen(target, options));
return globalHook;
};
describe('useFullscreen', () => {
beforeEach(() => {
targetEl = document.createElement('div');
document.body.appendChild(targetEl);
jest.spyOn(HTMLElement.prototype, 'requestFullscreen').mockImplementation(() => {
Object.defineProperty(document, 'fullscreenElement', {
value: targetEl,
});
return Promise.resolve();
});
jest.spyOn(document, 'exitFullscreen').mockImplementation(() => {
Object.defineProperty(document, 'fullscreenElement', {
value: null,
});
return Promise.resolve();
});
jest.spyOn(document, 'addEventListener').mockImplementation((eventName, callback) => {
if (events[eventName]) {
events[eventName].add(callback);
}
});
jest.spyOn(document, 'removeEventListener').mockImplementation((eventName, callback) => {
if (events[eventName]) {
events[eventName].delete(callback);
}
});
});
afterEach(() => {
document.body.removeChild(targetEl);
events.fullscreenchange.clear();
globalHook?.unmount();
});
afterAll(() => {
jest.resetAllMocks();
});
it('enterFullscreen/exitFullscreen should be work', () => {
const { result } = setup(targetEl);
const { enterFullscreen, exitFullscreen } = result.current[1];
enterFullscreen();
act(() => {
events.fullscreenchange.forEach((fn: any) => fn());
});
expect(result.current[0]).toBe(true);
exitFullscreen();
act(() => {
events.fullscreenchange.forEach((fn: any) => fn());
});
expect(result.current[0]).toBe(false);
});
it('toggleFullscreen should be work', () => {
const { result } = setup(targetEl);
const { toggleFullscreen } = result.current[1];
toggleFullscreen();
act(() => {
events.fullscreenchange.forEach((fn: any) => fn());
});
expect(result.current[0]).toBe(true);
toggleFullscreen();
act(() => {
events.fullscreenchange.forEach((fn: any) => fn());
});
expect(result.current[0]).toBe(false);
});
it('onExit/onEnter should be called', () => {
const onExit = jest.fn();
const onEnter = jest.fn();
const { result } = setup(targetEl, {
onExit,
onEnter,
});
const { toggleFullscreen } = result.current[1];
toggleFullscreen();
act(() => {
events.fullscreenchange.forEach((fn: any) => fn());
});
expect(onEnter).toBeCalled();
toggleFullscreen();
act(() => {
events.fullscreenchange.forEach((fn: any) => fn());
});
expect(onExit).toBeCalled();
});
it('onExit/onEnter should not be called', () => {
const onExit = jest.fn();
const onEnter = jest.fn();
const { result } = setup(targetEl, {
onExit,
onEnter,
});
const { exitFullscreen, enterFullscreen } = result.current[1];
// `onExit` should not be called when not full screen
exitFullscreen();
act(() => events.fullscreenchange.forEach((fn: any) => fn()));
expect(onExit).not.toBeCalled();
// Enter full screen
enterFullscreen();
act(() => events.fullscreenchange.forEach((fn: any) => fn()));
expect(onEnter).toBeCalled();
onEnter.mockReset();
// `onEnter` should not be called when full screen
enterFullscreen();
// There is no need to write: `act(() => events.fullscreenchange.forEach((fn: any) => fn()));`,
// because in a real browser, if it is already in full screen, calling `enterFullscreen` again
// will not trigger the `change` event.
expect(onEnter).not.toBeCalled();
});
it('pageFullscreen should be work', () => {
const PAGE_FULLSCREEN_CLASS_NAME = 'test-page-fullscreen';
const PAGE_FULLSCREEN_Z_INDEX = 101;
const onExit = jest.fn();
const onEnter = jest.fn();
const { result } = setup(targetEl, {
onExit,
onEnter,
pageFullscreen: {
className: PAGE_FULLSCREEN_CLASS_NAME,
zIndex: PAGE_FULLSCREEN_Z_INDEX,
},
});
const { toggleFullscreen } = result.current[1];
const getStyleEl = () => targetEl.querySelector('style');
act(() => toggleFullscreen());
expect(result.current[0]).toBe(true);
expect(onEnter).toBeCalled();
expect(targetEl.classList.contains(PAGE_FULLSCREEN_CLASS_NAME)).toBeTruthy();
expect(getStyleEl()).not.toBeNull();
expect(getStyleEl()?.textContent).toContain(`z-index: ${PAGE_FULLSCREEN_Z_INDEX}`);
expect(getStyleEl()?.getAttribute('id')).toBe(PAGE_FULLSCREEN_CLASS_NAME);
act(() => toggleFullscreen());
expect(result.current[0]).toBe(false);
expect(onExit).toBeCalled();
expect(targetEl.classList.contains(PAGE_FULLSCREEN_CLASS_NAME)).toBeFalsy();
expect(getStyleEl()).toBeNull();
expect(getStyleEl()?.textContent).toBeUndefined();
expect(getStyleEl()?.getAttribute('id')).toBeUndefined();
});
it('enterFullscreen should not work when target is not element', () => {
const onEnter = jest.fn();
const { result } = setup(null, { onEnter });
const { enterFullscreen } = result.current[1];
enterFullscreen();
expect(onEnter).not.toBeCalled();
});
it('should remove event listener when unmount', () => {
const { result, unmount } = setup(targetEl);
const { enterFullscreen } = result.current[1];
enterFullscreen();
const size = events.fullscreenchange.size;
unmount();
expect(events.fullscreenchange.size).toBe(size - 1);
});
it('`isFullscreen` should be false when use `document.exitFullscreen`', () => {
const { result } = setup(targetEl);
const { enterFullscreen } = result.current[1];
enterFullscreen();
act(() => {
events['fullscreenchange'].forEach((fn: any) => fn());
});
expect(result.current[0]).toBe(true);
document.exitFullscreen();
act(() => {
events['fullscreenchange'].forEach((fn: any) => fn());
});
expect(result.current[0]).toBe(false);
});
it('mutli element full screen should be correct', () => {
const targetEl2 = document.createElement('p');
const hook = setup(targetEl);
const hook2 = setup(targetEl2);
// target1 full screen
hook.result.current[1].enterFullscreen();
act(() => {
events['fullscreenchange'].forEach((fn: any) => fn());
});
expect(hook.result.current[0]).toBe(true);
// target2 full screen
hook2.result.current[1].enterFullscreen();
Object.defineProperty(document, 'fullscreenElement', {
value: targetEl2,
});
act(() => {
events['fullscreenchange'].forEach((fn: any) => fn());
});
expect(hook.result.current[0]).toBe(false);
expect(hook2.result.current[0]).toBe(true);
// target2 exit full screen
hook2.result.current[1].exitFullscreen();
Object.defineProperty(document, 'fullscreenElement', {
value: targetEl,
});
act(() => {
events['fullscreenchange'].forEach((fn: any) => fn());
});
expect(hook.result.current[0]).toBe(true);
expect(hook2.result.current[0]).toBe(false);
});
});
|
210 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useFusionTable | petrpan-code/alibaba/hooks/packages/hooks/src/useFusionTable/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useFusionTable from '../index';
import { sleep } from '../../utils/testingHelpers';
type Result = {
total: number;
list: any[];
};
let count = 0;
const total = 40;
const getTableData = async ({ current, pageSize }): Promise<Result> => {
if (count * current >= total) {
return {
total,
list: [],
};
}
await sleep(1000);
count++;
const list = new Array(pageSize).fill(1).map((item, i) => {
const index = current * pageSize + i;
return {
id: index,
name: 'test',
};
});
return {
total,
list,
};
};
let values = {};
const mockField = {
getNames() {
return [];
},
setValues(v) {
values = v;
},
getValues() {
return values;
},
resetToDefault() {
values = {};
},
validate(names, callback) {
callback(null, values);
},
};
const setup = (service, options = {}) => renderHook(() => useFusionTable(service, options));
describe('useFusionTable', () => {
beforeEach(() => {
count = 0;
values = {};
});
beforeAll(() => {
jest.useFakeTimers();
});
afterAll(() => {
jest.useRealTimers();
});
it('should get table & pagination props', async () => {
const { result } = setup(getTableData);
await act(async () => {
jest.runAllTimers();
});
expect(result.current.tableProps.loading).toBe(true);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.tableProps.loading).toBe(false);
expect(result.current.tableProps.dataSource).toHaveLength(10);
expect(result.current.paginationProps.current).toBe(1);
expect(result.current.paginationProps.total).toBe(total);
});
it('should get table data when page change', async () => {
const { result } = setup(getTableData);
const current = 2;
await act(async () => {
jest.runAllTimers();
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
act(() => {
result.current.paginationProps.onChange(current);
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.paginationProps.current).toBe(current);
expect(result.current.paginationProps.total).toBe(total);
});
it('search should work when set field instance', async () => {
const { result } = setup(getTableData, { field: mockField });
mockField.setValues({
name: 'ahooks',
});
result.current.search.submit();
await act(async () => {
jest.runAllTimers();
});
expect(result.current.loading).toBe(true);
expect(result.current.params[1]).toMatchObject({ name: 'ahooks' });
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBe(false);
result.current.search.reset();
expect(result.current.params[1]).toMatchObject({});
await act(async () => {
jest.runAllTimers();
});
expect(result.current.loading).toBe(true);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBe(false);
});
it('defaultParams should be work', async () => {
const { result } = setup(getTableData, {
defaultParams: [{ current: 2, pageSize: 20 }],
});
await act(async () => {
jest.runAllTimers();
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.tableProps.dataSource).toHaveLength(20);
expect(result.current.paginationProps.current).toBe(2);
});
it('cache should be work', async () => {
const options = {
field: mockField,
cacheKey: 'cache',
defaultParams: [
{
current: 2,
pageSize: 5,
},
{ name: 'hello', phone: '123' },
],
};
const hook = setup(getTableData, options);
await act(async () => {
jest.runAllTimers();
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(hook.result.current.tableProps.dataSource).toHaveLength(5);
expect(hook.result.current.loading).toBe(false);
hook.unmount();
const hook2 = setup(getTableData, options);
await act(async () => {
jest.runAllTimers();
});
expect(hook2.result.current.loading).toBe(false);
expect(hook2.result.current.tableProps.dataSource).toHaveLength(5);
});
it('onSort should be work', async () => {
const { result } = setup(getTableData);
act(() => {
result.current.tableProps.onSort('dataIndex', 'asc');
});
expect(result.current.loading).toBe(true);
expect(result.current.params[0]?.sorter).toMatchObject({ field: 'dataIndex', order: 'asc' });
});
it('onFilter should be work', async () => {
const { result } = setup(getTableData);
const filterParams = {
version: 3,
};
act(() => {
result.current.tableProps.onFilter(filterParams);
});
expect(result.current.loading).toBe(true);
expect(result.current.params[0]?.filters).toMatchObject(filterParams);
});
});
|
219 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useGetState | petrpan-code/alibaba/hooks/packages/hooks/src/useGetState/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useGetState from '../index';
describe('useGetState', () => {
const setUp = <T>(initialValue: T) =>
renderHook(() => {
const [state, setState, getState] = useGetState<T>(initialValue);
return {
state,
setState,
getState,
} as const;
});
it('should support initialValue', () => {
const hook = setUp(() => 0);
expect(hook.result.current.state).toBe(0);
});
it('should support update', () => {
const hook = setUp(0);
act(() => {
hook.result.current.setState(1);
});
expect(hook.result.current.getState()).toBe(1);
});
it('should getState frozen', () => {
const hook = setUp(0);
const prevGetState = hook.result.current.getState;
act(() => {
hook.result.current.setState(1);
});
expect(hook.result.current.getState).toBe(prevGetState);
});
});
|
224 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useHistoryTravel | petrpan-code/alibaba/hooks/packages/hooks/src/useHistoryTravel/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useHistoryTravel from '../index';
describe('useHistoryTravel', () => {
it('should work without initial value', async () => {
const hook = renderHook(() => useHistoryTravel());
expect(hook.result.current.value).toBeUndefined();
act(() => {
hook.result.current.setValue('test');
});
expect(hook.result.current.value).toBe('test');
});
it('should work with null and undefined without initial value', async () => {
const nullHook = renderHook(() => useHistoryTravel());
expect(nullHook.result.current.value).toBeUndefined();
act(() => {
nullHook.result.current.setValue(null);
});
expect(nullHook.result.current.value).toBeNull();
const undefHook = renderHook(() => useHistoryTravel());
expect(undefHook.result.current.value).toBeUndefined();
act(() => {
undefHook.result.current.setValue('def');
});
act(() => {
undefHook.result.current.setValue(undefined);
});
expect(undefHook.result.current.value).toBeUndefined();
expect(undefHook.result.current.backLength).toBe(2);
});
it('should work with initial value', async () => {
const hook = renderHook(() => useHistoryTravel('abc'));
expect(hook.result.current.value).toBe('abc');
act(() => {
hook.result.current.setValue('def');
});
expect(hook.result.current.value).toBe('def');
});
it('should work with null and undefined with initial value', async () => {
const nullHook = renderHook(() => useHistoryTravel<null | string>('abc'));
act(() => {
nullHook.result.current.setValue(null);
});
expect(nullHook.result.current.value).toBeNull();
const undefHook = renderHook(() => useHistoryTravel<undefined | string>('abc'));
act(() => {
undefHook.result.current.setValue(undefined);
});
expect(undefHook.result.current.value).toBeUndefined();
expect(undefHook.result.current.backLength).toBe(1);
});
it('back and forward should work', () => {
const hook = renderHook(() => useHistoryTravel());
act(() => {
hook.result.current.setValue('ddd');
});
act(() => {
hook.result.current.setValue('abc');
});
expect(hook.result.current.value).toBe('abc');
act(() => {
hook.result.current.setValue('def');
});
expect(hook.result.current.value).toBe('def');
act(() => {
hook.result.current.back();
});
expect(hook.result.current.value).toBe('abc');
act(() => {
hook.result.current.forward();
});
expect(hook.result.current.value).toBe('def');
});
it('go should work for negative step', () => {
const hook = renderHook(() => useHistoryTravel('init'));
act(() => {
hook.result.current.setValue('abc');
});
act(() => {
hook.result.current.setValue('def');
});
act(() => {
hook.result.current.setValue('hij');
});
act(() => {
hook.result.current.go(-2);
});
expect(hook.result.current.value).toBe('abc');
act(() => {
hook.result.current.go(-100);
});
expect(hook.result.current.value).toBe('init');
});
it('go should work for positive step', () => {
const hook = renderHook(() => useHistoryTravel('init'));
act(() => {
hook.result.current.setValue('abc');
});
act(() => {
hook.result.current.setValue('def');
});
act(() => {
hook.result.current.setValue('hij');
});
act(() => {
hook.result.current.go(-3);
});
expect(hook.result.current.value).toBe('init');
act(() => {
hook.result.current.go(2);
});
expect(hook.result.current.value).toBe('def');
act(() => {
hook.result.current.go(100);
});
expect(hook.result.current.value).toBe('hij');
});
it('reset should reset state to initial by default', () => {
const hook = renderHook(() => useHistoryTravel('init'));
act(() => {
hook.result.current.setValue('abc');
});
act(() => {
hook.result.current.setValue('def');
});
act(() => {
hook.result.current.setValue('hij');
});
act(() => {
hook.result.current.go(-1);
});
expect(hook.result.current.backLength).toBe(2);
expect(hook.result.current.forwardLength).toBe(1);
act(() => {
hook.result.current.reset();
});
expect(hook.result.current.value).toBe('init');
expect(hook.result.current.backLength).toBe(0);
expect(hook.result.current.forwardLength).toBe(0);
});
it('reset should reset state to new initial if provided', () => {
const hook = renderHook(() => useHistoryTravel('init'));
act(() => {
hook.result.current.setValue('abc');
});
act(() => {
hook.result.current.setValue('def');
});
act(() => {
hook.result.current.setValue('hij');
});
act(() => {
hook.result.current.go(-1);
});
expect(hook.result.current.backLength).toBe(2);
expect(hook.result.current.forwardLength).toBe(1);
act(() => {
hook.result.current.reset('new init');
});
expect(hook.result.current.value).toBe('new init');
expect(hook.result.current.backLength).toBe(0);
expect(hook.result.current.forwardLength).toBe(0);
});
it('reset new initial value should work with undefined', () => {
const hook = renderHook(() => useHistoryTravel('init'));
act(() => {
hook.result.current.setValue('abc');
});
act(() => {
hook.result.current.setValue('def');
});
act(() => {
hook.result.current.setValue('hij');
});
act(() => {
hook.result.current.go(-1);
});
expect(hook.result.current.backLength).toBe(2);
expect(hook.result.current.forwardLength).toBe(1);
act(() => {
hook.result.current.reset(undefined);
});
expect(hook.result.current.value).toBeUndefined();
expect(hook.result.current.backLength).toBe(0);
expect(hook.result.current.forwardLength).toBe(0);
});
it('should work without max length', async () => {
const hook = renderHook(() => useHistoryTravel());
expect(hook.result.current.backLength).toBe(0);
for (let i = 1; i <= 100; i++) {
act(() => {
hook.result.current.setValue(i);
});
}
expect(hook.result.current.forwardLength).toBe(0);
expect(hook.result.current.backLength).toBe(100);
expect(hook.result.current.value).toBe(100);
});
it('should work with max length', async () => {
const hook = renderHook(() => useHistoryTravel(0, 10));
expect(hook.result.current.backLength).toBe(0);
for (let i = 1; i <= 100; i++) {
act(() => {
hook.result.current.setValue(i);
});
}
expect(hook.result.current.forwardLength).toBe(0);
expect(hook.result.current.backLength).toBe(10);
expect(hook.result.current.value).toBe(100);
act(() => {
hook.result.current.go(-5);
});
expect(hook.result.current.forwardLength).toBe(5);
expect(hook.result.current.backLength).toBe(5);
expect(hook.result.current.value).toBe(95);
act(() => {
hook.result.current.go(5);
});
expect(hook.result.current.forwardLength).toBe(0);
expect(hook.result.current.backLength).toBe(10);
expect(hook.result.current.value).toBe(100);
act(() => {
hook.result.current.go(-50);
});
expect(hook.result.current.forwardLength).toBe(10);
expect(hook.result.current.backLength).toBe(0);
expect(hook.result.current.value).toBe(90);
});
});
|
231 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useHover | petrpan-code/alibaba/hooks/packages/hooks/src/useHover/__tests__/index.test.tsx | // write your test cases here
import React from 'react';
import { renderHook, act } from '@testing-library/react';
import { render, fireEvent } from '@testing-library/react';
import useHover from '../index';
describe('useHover', () => {
it('should work', () => {
const { getByText } = render(<button>Hover</button>);
let trigger = 0;
const { result } = renderHook(() =>
useHover(getByText('Hover'), {
onEnter: () => {
trigger++;
},
onLeave: () => {
trigger++;
},
}),
);
expect(result.current).toBe(false);
act(() => void fireEvent.mouseEnter(getByText('Hover')));
expect(result.current).toBe(true);
expect(trigger).toBe(1);
act(() => void fireEvent.mouseLeave(getByText('Hover')));
expect(result.current).toBe(false);
expect(trigger).toBe(2);
});
});
|
237 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useInViewport | petrpan-code/alibaba/hooks/packages/hooks/src/useInViewport/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useInViewport from '../index';
const targetEl = document.createElement('div');
document.body.appendChild(targetEl);
const observe = jest.fn();
const disconnect = jest.fn();
const mockIntersectionObserver = jest.fn().mockReturnValue({
observe,
disconnect,
});
window.IntersectionObserver = mockIntersectionObserver;
describe('useInViewport', () => {
it('should work when target is in viewport', async () => {
const { result } = renderHook(() => useInViewport(targetEl));
const calls = mockIntersectionObserver.mock.calls;
const [onChange] = calls[calls.length - 1];
act(() => {
onChange([
{
targetEl,
isIntersecting: true,
intersectionRatio: 0.5,
},
]);
});
const [inViewport, ratio] = result.current;
expect(inViewport).toBeTruthy();
expect(ratio).toBe(0.5);
});
it('should work when target array is in viewport and has a callback', async () => {
const targetEls: HTMLDivElement[] = [];
const callback = jest.fn();
for (let i = 0; i < 2; i++) {
const target = document.createElement('div');
document.body.appendChild(target);
targetEls.push(target);
}
const getValue = (isIntersecting, intersectionRatio) => ({ isIntersecting, intersectionRatio });
const { result } = renderHook(() => useInViewport(targetEls, { callback }));
const calls = mockIntersectionObserver.mock.calls;
const [observerCallback] = calls[calls.length - 1];
const target = getValue(false, 0);
act(() => observerCallback([target]));
expect(callback).toHaveBeenCalledWith(target);
expect(result.current[0]).toBe(false);
expect(result.current[1]).toBe(0);
const target1 = getValue(true, 0.5);
act(() => observerCallback([target1]));
expect(callback).toHaveBeenCalledWith(target1);
expect(result.current[0]).toBe(true);
expect(result.current[1]).toBe(0.5);
});
it('should not work when target is null', async () => {
renderHook(() => useInViewport(null));
const calls = mockIntersectionObserver.mock.calls;
expect(calls[calls.length - 1]).toBeUndefined();
});
it('should disconnect when unmount', async () => {
mockIntersectionObserver.mockReturnValue({
observe: () => null,
disconnect,
});
const { unmount } = renderHook(() => useInViewport(targetEl));
unmount();
expect(disconnect).toBeCalled();
});
});
|
245 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useInfiniteScroll | petrpan-code/alibaba/hooks/packages/hooks/src/useInfiniteScroll/__tests__/index.test.ts | import { useState } from 'react';
import { renderHook, act } from '@testing-library/react';
import useInfiniteScroll from '..';
import type { Data, Service, InfiniteScrollOptions } from '../types';
import { sleep } from '../../utils/testingHelpers';
let count = 0;
export async function mockRequest() {
await sleep(1000);
if (count >= 1) {
return { list: [] };
}
count++;
return {
list: [1, 2, 3],
nextId: count,
};
}
const targetEl = document.createElement('div');
const setup = <T extends Data>(service: Service<T>, options?: InfiniteScrollOptions<T>) =>
renderHook(() => useInfiniteScroll(service, options));
describe('useInfiniteScroll', () => {
beforeEach(() => {
count = 0;
});
beforeAll(() => {
jest.useFakeTimers();
});
afterAll(() => {
jest.useRealTimers();
});
it('should auto load', async () => {
const { result } = setup(mockRequest);
expect(result.current.loading).toBe(true);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBe(false);
});
it('loadMore should be work', async () => {
const { result } = setup(mockRequest, { manual: true });
const { loadMore, loading } = result.current;
expect(loading).toBe(false);
act(() => {
loadMore();
});
expect(result.current.loadingMore).toBe(true);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loadingMore).toBe(false);
});
it('noMore should be true when isNoMore is true', async () => {
const { result } = setup(mockRequest, {
isNoMore: (d) => d?.nextId === undefined,
});
const { loadMore } = result.current;
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.noMore).toBe(false);
act(() => loadMore());
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.noMore).toBe(true);
});
it('should auto load when scroll to bottom', async () => {
const events = {};
const mockAddEventListener = jest
.spyOn(targetEl, 'addEventListener')
.mockImplementation((eventName, callback) => {
events[eventName] = callback;
});
const { result } = setup(mockRequest, {
target: targetEl,
isNoMore: (d) => d?.nextId === undefined,
});
// not work when loading
expect(result.current.loading).toBe(true);
events['scroll']();
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBe(false);
// mock scroll
Object.defineProperties(targetEl, {
clientHeight: {
value: 150,
},
scrollHeight: {
value: 300,
},
scrollTop: {
value: 100,
},
});
act(() => {
events['scroll']();
});
expect(result.current.loadingMore).toBe(true);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loadingMore).toBe(false);
// not work when no more
expect(result.current.noMore).toBe(true);
act(() => {
events['scroll']();
});
expect(result.current.loadingMore).toBe(false);
mockAddEventListener.mockRestore();
});
it('reload should be work', async () => {
const fn = jest.fn(() => Promise.resolve({ list: [] }));
const { result } = setup(fn);
const { reload } = result.current;
expect(fn).toBeCalledTimes(1);
act(() => reload());
expect(fn).toBeCalledTimes(2);
await act(async () => {
Promise.resolve();
});
});
it('reload should be triggered when reloadDeps change', async () => {
const fn = jest.fn(() => Promise.resolve({ list: [] }));
const { result } = renderHook(() => {
const [value, setValue] = useState('');
const res = useInfiniteScroll(fn, {
reloadDeps: [value],
});
return {
...res,
setValue,
};
});
expect(fn).toBeCalledTimes(1);
act(() => {
result.current.setValue('ahooks');
});
expect(fn).toBeCalledTimes(2);
await act(async () => {
Promise.resolve();
});
});
it('reload data should be latest', async () => {
let listCount = 5;
const mockRequestFn = async () => {
await sleep(1000);
return {
list: Array.from({
length: listCount,
}).map((_, index) => index + 1),
nextId: listCount,
hasMore: listCount > 2,
};
};
const { result } = setup(mockRequestFn);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.data).toMatchObject({ list: [1, 2, 3, 4, 5], nextId: 5 });
listCount = 3;
await act(async () => {
result.current.reload();
jest.advanceTimersByTime(1000);
});
expect(result.current.data).toMatchObject({ list: [1, 2, 3], nextId: 3 });
});
it('mutate should be work', async () => {
const { result } = setup(mockRequest);
const { mutate } = result.current;
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.data).toMatchObject({ list: [1, 2, 3], nextId: 1 });
const newData = {
list: [1, 2],
nextId: 1,
};
act(() => mutate(newData));
expect(result.current.data).toMatchObject(newData);
});
it('cancel should be work', () => {
const onSuccess = jest.fn();
const { result } = setup(mockRequest, {
onSuccess,
});
const { cancel } = result.current;
expect(result.current.loading).toBe(true);
act(() => cancel());
expect(result.current.loading).toBe(false);
expect(onSuccess).not.toBeCalled();
});
it('onBefore/onSuccess/onFinally should be called', async () => {
const onBefore = jest.fn();
const onSuccess = jest.fn();
const onFinally = jest.fn();
const { result } = setup(mockRequest, {
onBefore,
onSuccess,
onFinally,
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(onBefore).toBeCalled();
expect(onSuccess).toBeCalled();
expect(onFinally).toBeCalled();
});
it('onError should be called when throw error', async () => {
const onError = jest.fn();
const mockRequestError = () => {
return Promise.reject('error');
};
setup(mockRequestError, {
onError,
});
await act(async () => {
Promise.resolve();
});
expect(onError).toBeCalled();
});
it('loadMoreAsync should be work', async () => {
const { result } = setup(mockRequest, {
manual: true,
});
const { loadMoreAsync } = result.current;
act(() => {
loadMoreAsync().then((res) => {
expect(res).toMatchObject({ list: [1, 2, 3], nextId: 1 });
expect(result.current.loading).toBe(false);
});
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
});
it('reloadAsync should be work', async () => {
const fn = jest.fn(() => Promise.resolve({ list: [] }));
const { result } = setup(fn);
const { reloadAsync } = result.current;
expect(fn).toBeCalledTimes(1);
act(() => {
reloadAsync().then(() => {
expect(fn).toBeCalledTimes(2);
});
});
await act(async () => {
Promise.resolve();
});
});
it('loading should be true when reload after loadMore', async () => {
const { result } = setup(mockRequest);
expect(result.current.loading).toBeTruthy();
const { reload, loadMore } = result.current;
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBeFalsy();
act(() => {
loadMore();
reload();
});
expect(result.current.loading).toBeTruthy();
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBeFalsy();
});
it('loading should be true when reloadAsync after loadMore', async () => {
const { result } = setup(mockRequest);
expect(result.current.loading).toBeTruthy();
const { reloadAsync, loadMore } = result.current;
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBeFalsy();
act(() => {
loadMore();
reloadAsync();
});
expect(result.current.loading).toBeTruthy();
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBeFalsy();
});
it('list can be null or undefined', async () => {
// @ts-ignore
const { result } = setup(async function () {
await sleep(1000);
count++;
return {
list: Math.random() < 0.5 ? null : undefined,
nextId: count,
};
});
expect(result.current.loading).toBeTruthy();
const { loadMore } = result.current;
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBeFalsy();
act(() => {
loadMore();
});
});
it('error result', async () => {
const { result } = setup(async () => {
throw new Error('error message');
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.error?.message).toBe('error message');
});
});
|
254 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useInterval | petrpan-code/alibaba/hooks/packages/hooks/src/useInterval/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useInterval from '../index';
interface ParamsObj {
fn: (...arg: any) => any;
delay: number | undefined;
options?: { immediate: boolean };
}
const setUp = ({ fn, delay, options }: ParamsObj) =>
renderHook(() => useInterval(fn, delay, options));
describe('useInterval', () => {
jest.useFakeTimers();
jest.spyOn(global, 'clearInterval');
it('interval should work', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: 20 });
expect(callback).not.toBeCalled();
jest.advanceTimersByTime(70);
expect(callback).toHaveBeenCalledTimes(3);
});
it('interval should stop', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: undefined });
jest.advanceTimersByTime(50);
expect(callback).toHaveBeenCalledTimes(0);
setUp({ fn: callback, delay: -2 });
jest.advanceTimersByTime(50);
expect(callback).toHaveBeenCalledTimes(0);
});
it('immediate in options should work', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: 20, options: { immediate: true } });
expect(callback).toBeCalled();
expect(callback).toHaveBeenCalledTimes(1);
jest.advanceTimersByTime(50);
expect(callback).toHaveBeenCalledTimes(3);
});
it('interval should be clear', () => {
const callback = jest.fn();
const hook = setUp({ fn: callback, delay: 20 });
expect(callback).not.toBeCalled();
hook.result.current();
jest.advanceTimersByTime(70);
// not to be called
expect(callback).toHaveBeenCalledTimes(0);
expect(clearInterval).toHaveBeenCalledTimes(1);
});
});
|
260 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useIsomorphicLayoutEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useIsomorphicLayoutEffect/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useIsomorphicLayoutEffect from '../index';
describe('useIsomorphicLayoutEffect', () => {
const callback = jest.fn();
const { result } = renderHook(() => useIsomorphicLayoutEffect(callback));
it('cheak return value', () => {
expect(result.current).toBeUndefined();
});
});
|
264 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useKeyPress | petrpan-code/alibaba/hooks/packages/hooks/src/useKeyPress/__tests__/index.test.tsx | import { renderHook } from '@testing-library/react';
import { fireEvent } from '@testing-library/react';
import useKeyPress from '../index';
const callback = jest.fn();
afterEach(() => {
callback.mockClear();
});
describe('useKeyPress ', () => {
it('test single key', async () => {
const { unmount } = renderHook(() => useKeyPress(['c'], callback));
fireEvent.keyDown(document, { key: 'c', keyCode: 67 });
expect(callback.mock.calls.length).toBe(1);
unmount();
});
it('test modifier key', async () => {
const { unmount } = renderHook(() => useKeyPress(['ctrl'], callback));
fireEvent.keyDown(document, { key: 'ctrl', keyCode: 17, ctrlKey: true });
expect(callback.mock.calls.length).toBe(1);
unmount();
});
it('test combination keys', async () => {
const hook1 = renderHook(() => useKeyPress(['shift.c'], callback));
const hook2 = renderHook(() => useKeyPress(['shift'], callback));
const hook3 = renderHook(() => useKeyPress(['c'], callback));
fireEvent.keyDown(document, { key: 'c', shiftKey: true, keyCode: 67 });
expect(callback.mock.calls.length).toBe(3);
hook1.unmount();
hook2.unmount();
hook3.unmount();
});
it('test combination keys by exact match', async () => {
const callbackShift = jest.fn();
const callbackC = jest.fn();
const callbackMulti = jest.fn();
const hook1 = renderHook(() => useKeyPress(['shift.c'], callback, { exactMatch: true }));
const hook2 = renderHook(() => useKeyPress(['shift'], callbackShift, { exactMatch: true }));
const hook3 = renderHook(() => useKeyPress(['c'], callbackC, { exactMatch: true }));
const hook4 = renderHook(() => useKeyPress(['ctrl.shift.c'], callbackMulti));
fireEvent.keyDown(document, { key: 'c', shiftKey: true, keyCode: 67 });
/**
* 只有 shift.c 才会触发，shift 和 c 都不应该触发
*/
expect(callback.mock.calls.length).toBe(1);
expect(callbackShift.mock.calls.length).toBe(0);
expect(callbackC.mock.calls.length).toBe(0);
callback.mockClear();
fireEvent.keyDown(document, { key: 'c', ctrlKey: true, shiftKey: true, keyCode: 67 });
expect(callbackMulti.mock.calls.length).toBe(1);
expect(callback.mock.calls.length).toBe(0);
expect(callbackC.mock.calls.length).toBe(0);
hook1.unmount();
hook2.unmount();
hook3.unmount();
hook4.unmount();
});
it('test multiple keys', async () => {
const { unmount } = renderHook(() => useKeyPress(['0', 65], callback));
fireEvent.keyDown(document, { key: '0', keyCode: 48 });
fireEvent.keyDown(document, { key: 'a', keyCode: 65 });
expect(callback.mock.calls.length).toBe(2);
unmount();
});
it('meta key should be work in keyup event', async () => {
renderHook(() =>
useKeyPress(['meta'], callback, {
events: ['keyup'],
}),
);
fireEvent.keyUp(document, { key: 'meta', keyCode: 91, metaKey: false });
expect(callback).toBeCalled();
});
it('test `keyFilter` function parameter', async () => {
const callback1 = jest.fn();
const callback2 = jest.fn();
// all keys can trigger callback
const hook1 = renderHook(() => useKeyPress(() => true, callback1));
fireEvent.keyDown(document, { key: '0', keyCode: 48 });
fireEvent.keyDown(document, { key: 'a', keyCode: 65 });
expect(callback1.mock.calls.length).toBe(2);
// only some keys can trigger callback
const hook2 = renderHook(() => useKeyPress((e) => ['0', 'meta'].includes(e.key), callback2));
fireEvent.keyDown(document, { key: '0', keyCode: 48 });
fireEvent.keyDown(document, { key: '1', keyCode: 49 });
fireEvent.keyDown(document, { key: 'ctrl', keyCode: 17, ctrlKey: true });
fireEvent.keyDown(document, { key: 'meta', keyCode: 91, metaKey: true });
expect(callback2.mock.calls.length).toBe(2);
hook1.unmount();
hook2.unmount();
});
it('test key in `eventHandler` parameter', async () => {
let pressedKey;
const KEYS = ['c', 'shift.c', 'shift.ctrl.c'];
const callbackKey = (e, key) => {
pressedKey = key;
};
// test `exactMatch: true` props
const hook1 = renderHook(() => useKeyPress(KEYS, callbackKey, { exactMatch: true }));
fireEvent.keyDown(document, { key: 'c', keyCode: 67 });
expect(pressedKey).toBe('c');
fireEvent.keyDown(document, { key: 'c', keyCode: 67, shiftKey: true });
expect(pressedKey).toBe('shift.c');
fireEvent.keyDown(document, { key: 'c', keyCode: 67, shiftKey: true, ctrlKey: true });
expect(pressedKey).toBe('shift.ctrl.c');
// test `exactMatch: false`(default) props
const hook2 = renderHook(() => useKeyPress(KEYS, callbackKey));
fireEvent.keyDown(document, { key: 'c', keyCode: 67 });
expect(pressedKey).toBe('c');
fireEvent.keyDown(document, { key: 'c', keyCode: 67, shiftKey: true });
expect(pressedKey).toBe('c');
fireEvent.keyDown(document, { key: 'c', keyCode: 67, shiftKey: true, ctrlKey: true });
expect(pressedKey).toBe('c');
hook2.unmount();
hook1.unmount();
});
});
|
276 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useLatest | petrpan-code/alibaba/hooks/packages/hooks/src/useLatest/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useLatest from '../index';
const setUp = (val) => renderHook((state) => useLatest(state), { initialProps: val });
describe('useLatest', () => {
it('useLatest with basic variable should work', async () => {
const { result, rerender } = setUp(0);
rerender(1);
expect(result.current.current).toBe(1);
rerender(2);
expect(result.current.current).toBe(2);
rerender(3);
expect(result.current.current).toBe(3);
});
it('useLatest with reference variable should work', async () => {
const { result, rerender } = setUp({});
expect(result.current.current).toEqual({});
rerender([]);
expect(result.current.current).toEqual([]);
});
});
|
281 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useLocalStorageState | petrpan-code/alibaba/hooks/packages/hooks/src/useLocalStorageState/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useLocalStorageState from '../index';
describe('useLocalStorageState', () => {
const setUp = <T>(key: string, value: T) =>
renderHook(() => {
const [state, setState] = useLocalStorageState<T>(key, { defaultValue: value });
return {
state,
setState,
} as const;
});
it('getKey should work', () => {
const LOCAL_STORAGE_KEY = 'test-key';
const hook = setUp(LOCAL_STORAGE_KEY, 'A');
expect(hook.result.current.state).toBe('A');
act(() => {
hook.result.current.setState('B');
});
expect(hook.result.current.state).toBe('B');
const anotherHook = setUp(LOCAL_STORAGE_KEY, 'A');
expect(anotherHook.result.current.state).toBe('B');
act(() => {
anotherHook.result.current.setState('C');
});
expect(anotherHook.result.current.state).toBe('C');
expect(hook.result.current.state).toBe('B');
});
it('should support object', () => {
const LOCAL_STORAGE_KEY = 'test-object-key';
const hook = setUp<{ name: string }>(LOCAL_STORAGE_KEY, {
name: 'A',
});
expect(hook.result.current.state).toEqual({ name: 'A' });
act(() => {
hook.result.current.setState({ name: 'B' });
});
expect(hook.result.current.state).toEqual({ name: 'B' });
const anotherHook = setUp(LOCAL_STORAGE_KEY, {
name: 'C',
});
expect(anotherHook.result.current.state).toEqual({ name: 'B' });
act(() => {
anotherHook.result.current.setState({
name: 'C',
});
});
expect(anotherHook.result.current.state).toEqual({ name: 'C' });
expect(hook.result.current.state).toEqual({ name: 'B' });
});
it('should support number', () => {
const LOCAL_STORAGE_KEY = 'test-number-key';
const hook = setUp(LOCAL_STORAGE_KEY, 1);
expect(hook.result.current.state).toBe(1);
act(() => {
hook.result.current.setState(2);
});
expect(hook.result.current.state).toBe(2);
const anotherHook = setUp(LOCAL_STORAGE_KEY, 3);
expect(anotherHook.result.current.state).toBe(2);
act(() => {
anotherHook.result.current.setState(3);
});
expect(anotherHook.result.current.state).toBe(3);
expect(hook.result.current.state).toBe(2);
});
it('should support boolean', () => {
const LOCAL_STORAGE_KEY = 'test-boolean-key';
const hook = setUp(LOCAL_STORAGE_KEY, true);
expect(hook.result.current.state).toBe(true);
act(() => {
hook.result.current.setState(false);
});
expect(hook.result.current.state).toBe(false);
const anotherHook = setUp(LOCAL_STORAGE_KEY, true);
expect(anotherHook.result.current.state).toBe(false);
act(() => {
anotherHook.result.current.setState(true);
});
expect(anotherHook.result.current.state).toBe(true);
expect(hook.result.current.state).toBe(false);
});
it('should support null', () => {
const LOCAL_STORAGE_KEY = 'test-boolean-key-with-null';
const hook = setUp<boolean | null>(LOCAL_STORAGE_KEY, false);
expect(hook.result.current.state).toBe(false);
act(() => {
hook.result.current.setState(null);
});
expect(hook.result.current.state).toBeNull();
const anotherHook = setUp(LOCAL_STORAGE_KEY, false);
expect(anotherHook.result.current.state).toBeNull();
});
it('should support function updater', () => {
const LOCAL_STORAGE_KEY = 'test-func-updater';
const hook = setUp<string | null>(LOCAL_STORAGE_KEY, 'hello world');
expect(hook.result.current.state).toBe('hello world');
act(() => {
hook.result.current.setState((state) => `${state}, zhangsan`);
});
expect(hook.result.current.state).toBe('hello world, zhangsan');
});
});
|
288 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useLockFn | petrpan-code/alibaba/hooks/packages/hooks/src/useLockFn/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import { useRef, useCallback, useState } from 'react';
import useLockFn from '../index';
import { sleep } from '../../utils/testingHelpers';
describe('useLockFn', () => {
const setUp = (): any =>
renderHook(() => {
const [tag, updateTag] = useState(false);
const countRef = useRef(0);
const persistFn = useCallback(
async (step: number) => {
countRef.current += step;
await sleep(50);
},
[tag],
);
const locked = useLockFn(persistFn);
return {
locked,
countRef,
updateTag: () => updateTag(true),
};
});
it('should work', async () => {
const hook = setUp();
const { locked, countRef } = hook.result.current;
locked(1);
expect(countRef.current).toBe(1);
locked(2);
expect(countRef.current).toBe(1);
await sleep(30);
locked(3);
expect(countRef.current).toBe(1);
await sleep(30);
locked(4);
expect(countRef.current).toBe(5);
locked(5);
expect(countRef.current).toBe(5);
});
it('should same', () => {
const hook = setUp();
const preLocked = hook.result.current.locked;
hook.rerender();
expect(hook.result.current.locked).toEqual(preLocked);
act(hook.result.current.updateTag);
expect(hook.result.current.locked).not.toEqual(preLocked);
});
});
|
293 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useLongPress | petrpan-code/alibaba/hooks/packages/hooks/src/useLongPress/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useLongPress from '../index';
import type { Options } from '../index';
const mockCallback = jest.fn();
const mockClickCallback = jest.fn();
const mockLongPressEndCallback = jest.fn();
let events = {};
const mockTarget = {
addEventListener: jest.fn((event, callback) => {
events[event] = callback;
}),
removeEventListener: jest.fn((event) => {
Reflect.deleteProperty(events, event);
}),
};
const setup = (onLongPress: any, target, options?: Options) =>
renderHook(() => useLongPress(onLongPress, target, options));
describe('useLongPress', () => {
beforeEach(() => {
jest.useFakeTimers();
});
afterEach(() => {
events = {};
jest.useRealTimers();
});
it('longPress callback correct', () => {
setup(mockCallback, mockTarget, {
onClick: mockClickCallback,
onLongPressEnd: mockLongPressEndCallback,
});
expect(mockTarget.addEventListener).toBeCalled();
events['mousedown']();
jest.advanceTimersByTime(350);
events['mouseleave']();
expect(mockCallback).toBeCalledTimes(1);
expect(mockLongPressEndCallback).toBeCalledTimes(1);
expect(mockClickCallback).toBeCalledTimes(0);
});
it('click callback correct', () => {
setup(mockCallback, mockTarget, {
onClick: mockClickCallback,
onLongPressEnd: mockLongPressEndCallback,
});
expect(mockTarget.addEventListener).toBeCalled();
events['mousedown']();
events['mouseup']();
events['mousedown']();
events['mouseup']();
expect(mockCallback).toBeCalledTimes(0);
expect(mockLongPressEndCallback).toBeCalledTimes(0);
expect(mockClickCallback).toBeCalledTimes(2);
});
it('longPress and click callback correct', () => {
setup(mockCallback, mockTarget, {
onClick: mockClickCallback,
onLongPressEnd: mockLongPressEndCallback,
});
expect(mockTarget.addEventListener).toBeCalled();
events['mousedown']();
jest.advanceTimersByTime(350);
events['mouseup']();
events['mousedown']();
events['mouseup']();
expect(mockCallback).toBeCalledTimes(1);
expect(mockLongPressEndCallback).toBeCalledTimes(1);
expect(mockClickCallback).toBeCalledTimes(1);
});
it('onLongPress should not be called when over the threshold', () => {
const { unmount } = setup(mockCallback, mockTarget, {
moveThreshold: {
x: 30,
y: 20,
},
});
expect(events['mousemove']).toBeDefined();
events['mousedown'](new MouseEvent('mousedown'));
events['mousemove'](
new MouseEvent('mousemove', {
clientX: 40,
clientY: 10,
}),
);
jest.advanceTimersByTime(320);
expect(mockCallback).not.toBeCalled();
unmount();
expect(events['mousemove']).toBeUndefined();
});
it(`should not work when target don't support addEventListener method`, () => {
Object.defineProperty(mockTarget, 'addEventListener', {
get() {
return false;
},
});
setup(() => {}, mockTarget);
expect(Object.keys(events)).toHaveLength(0);
});
});
|
300 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useMap | petrpan-code/alibaba/hooks/packages/hooks/src/useMap/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useMap from '../index';
const setup = (initialMap?: Iterable<[any, any]>) => renderHook(() => useMap(initialMap));
describe('useMap', () => {
it('should init map and utils', () => {
const { result } = setup([
['foo', 'bar'],
['a', 1],
]);
const [map, utils] = result.current;
expect(Array.from(map)).toEqual([
['foo', 'bar'],
['a', 1],
]);
expect(utils).toStrictEqual({
get: expect.any(Function),
set: expect.any(Function),
setAll: expect.any(Function),
remove: expect.any(Function),
reset: expect.any(Function),
});
});
it('should init empty map if not initial object provided', () => {
const { result } = setup();
expect([...result.current[0]]).toEqual([]);
const { result: result2 } = setup(undefined);
expect([...result2.current[0]]).toEqual([]);
});
it('should get corresponding value for initial provided key', () => {
const { result } = setup([
['foo', 'bar'],
['a', 1],
]);
const [, utils] = result.current;
let value;
act(() => {
value = utils.get('a');
});
expect(value).toBe(1);
});
it('should get corresponding value for existing provided key', () => {
const { result } = setup([
['foo', 'bar'],
['a', 1],
]);
act(() => {
result.current[1].set('a', 99);
});
let value;
act(() => {
value = result.current[1].get('a');
});
expect(value).toBe(99);
});
it('should get undefined for non-existing provided key', () => {
const { result } = setup([
['foo', 'bar'],
['a', 1],
]);
const [, utils] = result.current;
let value;
act(() => {
value = utils.get('nonExisting');
});
expect(value).toBeUndefined();
});
it('should set new key-value pair', () => {
const { result } = setup([
['foo', 'bar'],
['a', 1],
]);
const [, utils] = result.current;
act(() => {
utils.set('newKey', 99);
});
expect([...result.current[0]]).toEqual([
['foo', 'bar'],
['a', 1],
['newKey', 99],
]);
});
it('should override current value if setting existing key', () => {
const { result } = setup([
['foo', 'bar'],
['a', 1],
]);
const [, utils] = result.current;
act(() => {
utils.set('foo', 'qux');
});
expect([...result.current[0]]).toEqual([
['foo', 'qux'],
['a', 1],
]);
});
it('should set new map', () => {
const { result } = setup([
['foo', 'bar'],
['a', 1],
]);
const [, utils] = result.current;
act(() => {
utils.setAll([
['foo', 'foo'],
['a', 2],
]);
});
expect([...result.current[0]]).toEqual([
['foo', 'foo'],
['a', 2],
]);
act(() => {
// @ts-ignore
utils.setAll();
});
expect([...result.current[0]]).toEqual([]);
});
it('remove should be work', () => {
const { result } = setup([['msg', 'hello']]);
const { remove } = result.current[1];
expect(result.current[0].size).toBe(1);
act(() => {
remove('msg');
});
expect(result.current[0].size).toBe(0);
const { result: result2 } = setup([
['foo', 'bar'],
['a', 1],
['b', 2],
['c', 3],
]);
const [, utils] = result2.current;
act(() => {
utils.remove('a');
});
expect([...result2.current[0]]).toEqual([
['foo', 'bar'],
['b', 2],
['c', 3],
]);
});
it('reset should be work', () => {
const { result } = setup([['msg', 'hello']]);
const { set, reset } = result.current[1];
act(() => {
set('text', 'new map');
});
expect([...result.current[0]]).toEqual([
['msg', 'hello'],
['text', 'new map'],
]);
act(() => {
reset();
});
expect([...result.current[0]]).toEqual([['msg', 'hello']]);
});
});
|
305 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useMemoizedFn | petrpan-code/alibaba/hooks/packages/hooks/src/useMemoizedFn/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import { useState } from 'react';
import useMemoizedFn from '../';
const useCount = () => {
const [count, setCount] = useState(0);
const addCount = () => {
setCount((c) => c + 1);
};
const memoizedFn = useMemoizedFn(() => count);
return { addCount, memoizedFn };
};
let hook;
describe('useMemoizedFn', () => {
it('useMemoizedFn should work', () => {
act(() => {
hook = renderHook(() => useCount());
});
const currentFn = hook.result.current.memoizedFn;
expect(hook.result.current.memoizedFn()).toBe(0);
act(() => {
hook.result.current.addCount();
});
expect(currentFn).toEqual(hook.result.current.memoizedFn);
expect(hook.result.current.memoizedFn()).toBe(1);
});
// it('should output error when fn is not a function', () => {
// const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
// renderHook(() => useMemoizedFn(1 as any));
// expect(errSpy).toBeCalledWith('useMemoizedFn expected parameter is a function, got number');
// errSpy.mockRestore();
// });
});
|
311 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useMount | petrpan-code/alibaba/hooks/packages/hooks/src/useMount/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useMount from '../index';
describe('useMount', () => {
it('test mount', async () => {
const fn = jest.fn();
const hook = renderHook(() => useMount(fn));
expect(fn).toBeCalledTimes(1);
hook.rerender();
expect(fn).toBeCalledTimes(1);
hook.unmount();
expect(fn).toBeCalledTimes(1);
renderHook(() => useMount(fn)).unmount();
expect(fn).toBeCalledTimes(2);
});
// it('should output error when fn is not a function', () => {
// const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
// renderHook(() => useMount(1 as any));
// expect(errSpy).toBeCalledWith(
// 'useMount: parameter `fn` expected to be a function, but got "number".',
// );
// errSpy.mockRestore();
// });
});
|
316 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useMouse | petrpan-code/alibaba/hooks/packages/hooks/src/useMouse/__tests__/index.test.ts | import { renderHook, waitFor } from '@testing-library/react';
import useMouse from '../index';
describe('useMouse', () => {
function moveMouse(x: number, y: number) {
document.dispatchEvent(
new MouseEvent('mousemove', {
clientX: x,
clientY: y,
screenX: x,
screenY: y,
}),
);
}
it('on mouseMove', async () => {
const hook = renderHook(() => useMouse());
expect(hook.result.current.pageX).toBeNaN();
expect(hook.result.current.pageY).toBeNaN();
moveMouse(10, 10);
// can't manually set pageX & pageY for mouseEvent, default undefined here.
await waitFor(() => expect(hook.result.current.pageX).toBeUndefined());
expect(hook.result.current.pageY).toBeUndefined();
expect(hook.result.current.clientX).toBe(10);
expect(hook.result.current.clientY).toBe(10);
expect(hook.result.current.screenX).toBe(10);
expect(hook.result.current.screenY).toBe(10);
});
it('should be work with target', async () => {
const events = {};
const getBoundingClientRectMock = jest.spyOn(HTMLElement.prototype, 'getBoundingClientRect');
jest.spyOn(document, 'addEventListener').mockImplementation(
jest.fn((event: any, callback: any) => {
events[event] = callback;
}),
);
const targetEl = document.createElement('div');
getBoundingClientRectMock.mockReturnValue({
left: 100,
top: 100,
width: 200,
height: 200,
} as DOMRect);
const { result } = renderHook(() => useMouse(targetEl));
events['mousemove']({ pageX: 100, pageY: 100 });
await waitFor(() => expect(result.current.elementX).toBe(0));
expect(result.current.elementX).toBe(0);
expect(result.current.elementY).toBe(0);
expect(result.current.elementPosX).toBe(100);
expect(result.current.elementPosY).toBe(100);
});
});
|
322 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useMutationObserver | petrpan-code/alibaba/hooks/packages/hooks/src/useMutationObserver/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useMutationObserver from '../index';
const options: MutationObserverInit = { attributes: true, childList: true };
describe('useMutationObserver', () => {
let container: HTMLDivElement;
beforeEach(() => {
container = document.createElement('div');
document.body.appendChild(container);
});
afterEach(() => {
document.body.removeChild(container);
});
it('should callback work when target style be changed', async () => {
const callback = jest.fn();
const { rerender } = renderHook(() => useMutationObserver(callback, () => container, options));
container.style.backgroundColor = '#000';
await rerender();
expect(callback).toBeCalled();
});
it('should callback work when target node tree be changed', async () => {
const callback = jest.fn();
const { rerender } = renderHook(() => useMutationObserver(callback, () => container, options));
const paraEl = document.createElement('p');
container.appendChild(paraEl);
await rerender();
expect(callback).toBeCalled();
});
it('should not work when target is null', async () => {
const callback = jest.fn();
const { rerender } = renderHook(() => useMutationObserver(callback, null, options));
container.style.backgroundColor = '#000';
await rerender();
expect(callback).not.toBeCalled();
});
});
|
327 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useNetwork | petrpan-code/alibaba/hooks/packages/hooks/src/useNetwork/__tests__/index.test.ts | import useNetwork from '../index';
import { renderHook, act } from '@testing-library/react';
describe('useNetwork', () => {
it('toggle network state', () => {
const { result } = renderHook(() => useNetwork());
expect(result.current.online).toBeTruthy();
act(() => {
window.dispatchEvent(new Event('offline'));
});
expect(result.current.online).toBeFalsy();
act(() => {
window.dispatchEvent(new Event('online'));
});
expect(result.current.online).toBeTruthy();
});
});
|
333 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/usePagination | petrpan-code/alibaba/hooks/packages/hooks/src/usePagination/__tests__/index.test.ts | import { renderHook, act, waitFor } from '@testing-library/react';
import usePagination from '../';
// 初始化
// 基本 action
// refreshDeps
// cache
describe('usePagination', () => {
let queryArgs;
const asyncFn = (query) => {
queryArgs = query;
return Promise.resolve({
current: query.current,
total: 55,
pageSize: query.pageSize,
list: [],
});
};
const setUp = (service, options) => renderHook((o) => usePagination(service, o || options));
let hook;
it('should fetch after first render', async () => {
queryArgs = undefined;
act(() => {
hook = setUp(asyncFn, {});
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(1);
expect(queryArgs.pageSize).toBe(10);
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.pagination.current).toBe(1);
expect(hook.result.current.pagination.pageSize).toBe(10);
expect(hook.result.current.pagination.total).toBe(55);
expect(hook.result.current.pagination.totalPage).toBe(6);
});
it('should action work', async () => {
queryArgs = undefined;
act(() => {
hook = setUp(asyncFn, {});
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(1);
expect(queryArgs.pageSize).toBe(10);
await waitFor(() => expect(hook.result.current.loading).toBe(false));
act(() => {
hook.result.current.pagination.changeCurrent(2);
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(2);
expect(queryArgs.pageSize).toBe(10);
await waitFor(() => expect(hook.result.current.pagination.current).toBe(2));
act(() => {
hook.result.current.pagination.changeCurrent(10);
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(6);
expect(queryArgs.pageSize).toBe(10);
await waitFor(() => expect(hook.result.current.pagination.current).toBe(6));
act(() => {
hook.result.current.pagination.changePageSize(20);
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(3);
expect(queryArgs.pageSize).toBe(20);
await waitFor(() => expect(hook.result.current.pagination.current).toBe(3));
expect(hook.result.current.pagination.pageSize).toBe(20);
expect(hook.result.current.pagination.totalPage).toBe(3);
act(() => {
hook.result.current.pagination.onChange(2, 10);
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(2);
expect(queryArgs.pageSize).toBe(10);
await waitFor(() => expect(hook.result.current.pagination.current).toBe(2));
expect(hook.result.current.pagination.pageSize).toBe(10);
expect(hook.result.current.pagination.totalPage).toBe(6);
});
it('should refreshDeps work', async () => {
queryArgs = undefined;
let dep = 1;
act(() => {
hook = setUp(asyncFn, {
refreshDeps: [dep],
});
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(1);
expect(queryArgs.pageSize).toBe(10);
await waitFor(() => expect(hook.result.current.loading).toBe(false));
act(() => {
hook.result.current.pagination.onChange(3, 20);
});
expect(hook.result.current.loading).toBe(true);
await waitFor(() => expect(hook.result.current.pagination.current).toBe(3));
expect(hook.result.current.pagination.pageSize).toBe(20);
dep = 2;
hook.rerender({
refreshDeps: [dep],
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(1);
expect(queryArgs.pageSize).toBe(20);
await waitFor(() => expect(hook.result.current.pagination.current).toBe(1));
expect(hook.result.current.pagination.pageSize).toBe(20);
});
it('should default params work', async () => {
queryArgs = undefined;
act(() => {
hook = setUp(asyncFn, {
defaultPageSize: 5,
defaultCurrent: 2,
});
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(2);
expect(queryArgs.pageSize).toBe(5);
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.pagination.current).toBe(2);
expect(hook.result.current.pagination.pageSize).toBe(5);
expect(hook.result.current.pagination.total).toBe(55);
expect(hook.result.current.pagination.totalPage).toBe(11);
act(() => {
hook.result.current.pagination.changeCurrent(3);
});
expect(hook.result.current.loading).toBe(true);
expect(queryArgs.current).toBe(3);
expect(queryArgs.pageSize).toBe(5);
await waitFor(() => expect(hook.result.current.pagination.current).toBe(3));
expect(hook.result.current.pagination.pageSize).toBe(5);
});
});
|
341 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/usePrevious | petrpan-code/alibaba/hooks/packages/hooks/src/usePrevious/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import type { ShouldUpdateFunc } from '../';
import usePrevious from '../';
describe('usePrevious', () => {
function getHook<T>(initialValue?: T, compareFunction?: ShouldUpdateFunc<T>) {
return renderHook(({ val, cmp }) => usePrevious<T>(val as T, cmp), {
initialProps: {
val: initialValue || 0,
cmp: compareFunction,
} as { val?: T; cmp?: ShouldUpdateFunc<T> },
});
}
it('should return undefined on init', () => {
expect(getHook().result.current).toBeUndefined();
});
it('should update previous value only after render with different value', () => {
const hook = getHook(0, () => true);
expect(hook.result.current).toBeUndefined();
hook.rerender({ val: 1 });
expect(hook.result.current).toBe(0);
hook.rerender({ val: 2 });
expect(hook.result.current).toBe(1);
hook.rerender({ val: 3 });
expect(hook.result.current).toBe(2);
hook.rerender({ val: 4 });
expect(hook.result.current).toBe(3);
hook.rerender({ val: 5 });
expect(hook.result.current).toBe(4);
});
it('should not update previous value if current value is the same', () => {
const hook = getHook(0);
expect(hook.result.current).toBeUndefined();
hook.rerender({ val: 1 });
expect(hook.result.current).toBe(0);
hook.rerender({ val: 1 });
expect(hook.result.current).toBe(0);
});
it('should work fine with `undefined` values', () => {
const hook = renderHook(({ value }) => usePrevious(value), {
initialProps: { value: undefined as undefined | number },
});
expect(hook.result.current).toBeUndefined();
hook.rerender({ value: 1 });
expect(hook.result.current).toBeUndefined();
hook.rerender({ value: undefined });
expect(hook.result.current).toBe(1);
hook.rerender({ value: 2 });
expect(hook.result.current).toBeUndefined();
});
it('should receive a predicate as a second parameter that will compare prev and current', () => {
const obj1 = { label: 'John', value: 'john' };
const obj2 = { label: 'Jonny', value: 'john' };
const obj3 = { label: 'Kate', value: 'kate' };
type Obj = { label: string; value: string };
const predicate = (a: Obj | undefined, b: Obj) => (a ? a.value !== b.value : true);
const hook = getHook(obj1 as Obj, predicate);
expect(hook.result.current).toBeUndefined();
hook.rerender({ val: obj2, cmp: predicate });
expect(hook.result.current).toBeUndefined();
hook.rerender({ val: obj3, cmp: predicate });
expect(hook.result.current).toBe(obj1);
});
});
|
347 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRafInterval | petrpan-code/alibaba/hooks/packages/hooks/src/useRafInterval/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useRafInterval from '../index';
interface ParamsObj {
fn: (...arg: any) => any;
delay: number | undefined;
options?: { immediate: boolean };
}
const setUp = ({ fn, delay, options }: ParamsObj) =>
renderHook(() => useRafInterval(fn, delay, options));
const FRAME_TIME = 16;
describe('useRafInterval', () => {
beforeAll(() => {
jest.useFakeTimers({ legacyFakeTimers: false });
});
afterAll(() => {
jest.restoreAllMocks();
});
it('interval should work', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: FRAME_TIME });
expect(callback).not.toBeCalled();
jest.advanceTimersByTime(FRAME_TIME * 2.5);
expect(callback).toHaveBeenCalledTimes(2);
});
it('delay is undefined should stop', () => {
const delay: number | undefined = undefined;
const callback = jest.fn();
setUp({ fn: callback, delay });
expect(callback).not.toBeCalled();
jest.advanceTimersByTime(FRAME_TIME * 1.5);
expect(callback).not.toBeCalled();
});
it('immediate in options should work', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: FRAME_TIME, options: { immediate: true } });
expect(callback).toBeCalled();
expect(callback).toHaveBeenCalledTimes(1);
jest.advanceTimersByTime(FRAME_TIME * 1.5);
expect(callback).toHaveBeenCalledTimes(2);
});
it('interval should be clear', () => {
const callback = jest.fn();
const hook = setUp({ fn: callback, delay: FRAME_TIME });
expect(callback).not.toBeCalled();
hook.result.current();
jest.advanceTimersByTime(FRAME_TIME * 2.5);
// not to be called
expect(callback).toHaveBeenCalledTimes(0);
});
});
|
354 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRafState | petrpan-code/alibaba/hooks/packages/hooks/src/useRafState/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useRafState from '../index';
describe('useRafState', () => {
it('should work', () => {
const mockRaf = jest
.spyOn(window, 'requestAnimationFrame')
.mockImplementation((cb: FrameRequestCallback) => {
cb(0);
return 0;
});
const { result } = renderHook(() => useRafState(0));
const setRafState = result.current[1];
expect(result.current[0]).toBe(0);
act(() => {
setRafState(1);
});
expect(result.current[0]).toBe(1);
mockRaf.mockRestore();
});
});
|
359 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRafTimeout | petrpan-code/alibaba/hooks/packages/hooks/src/useRafTimeout/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useRafTimeout from '../index';
interface ParamsObj {
fn: (...arg: any) => any;
delay: number | undefined;
}
const setUp = ({ fn, delay }: ParamsObj) => renderHook(() => useRafTimeout(fn, delay));
const FRAME_TIME = 16.7;
describe('useRafTimeout', () => {
beforeAll(() => {
jest.useFakeTimers({ legacyFakeTimers: false });
});
afterAll(() => {
jest.restoreAllMocks();
});
it('timeout should work', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: FRAME_TIME });
expect(callback).not.toBeCalled();
jest.advanceTimersByTime(FRAME_TIME * 2.5);
expect(callback).toHaveBeenCalledTimes(1);
});
it('timeout should stop when delay is undefined', () => {
const delay: number | undefined = undefined;
const callback = jest.fn();
setUp({ fn: callback, delay });
expect(callback).not.toBeCalled();
jest.advanceTimersByTime(FRAME_TIME * 1.5);
expect(callback).not.toBeCalled();
});
it('timeout should be clear', () => {
const callback = jest.fn();
const hook = setUp({ fn: callback, delay: FRAME_TIME });
expect(callback).not.toBeCalled();
hook.result.current();
jest.advanceTimersByTime(FRAME_TIME * 2.5);
expect(callback).toHaveBeenCalledTimes(0);
});
});
|
366 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useReactive | petrpan-code/alibaba/hooks/packages/hooks/src/useReactive/__tests__/index.test.tsx | import { fireEvent, render, renderHook, act } from '@testing-library/react';
import React from 'react';
import useReactive from '../';
const Demo = () => {
const state: {
count: number;
val: any;
foo?: string;
arr: number[];
} = useReactive({
count: 0,
val: {
val1: {
val2: '',
},
},
arr: [1],
foo: 'foo',
});
return (
<div>
<p>
counter state.count：<span role="addCount">{state.count}</span>
</p>
<p>
delete property：<span role="deleteProperty">{state.foo}</span>
</p>
<button role="addCountBtn" onClick={() => (state.count += 1)}>
state.count++
</button>
<button role="deletePropertyBtn" onClick={() => delete state.foo}>
delete state.foo
</button>
<button role="subCountBtn" style={{ marginLeft: '50px' }} onClick={() => (state.count -= 1)}>
state.count--
</button>
<br />
<br />
<p>
state.arr: <span role="test-array">{JSON.stringify(state.arr)}</span>
</p>
<button style={{ marginRight: '10px' }} onClick={() => state.arr.push(1)} role="pushbtn">
push
</button>
<button style={{ marginRight: '10px' }} onClick={() => state.arr.pop()} role="popbtn">
pop
</button>
<button style={{ marginRight: '10px' }} onClick={() => state.arr.shift()} role="shiftbtn">
shift
</button>
<button
style={{ marginRight: '10px' }}
role="unshiftbtn"
onClick={() => state.arr.unshift(2)}
>
unshift
</button>
<button style={{ marginRight: '10px' }} role="reverse" onClick={() => state.arr.reverse()}>
reverse
</button>
<button style={{ marginRight: '10px' }} role="sort" onClick={() => state.arr.sort()}>
sort
</button>
<br />
<br />
<p>nested structure</p>
<p role="inputVal1">{state.val.val1.val2}</p>
<input
role="input1"
style={{ width: 220, borderWidth: 1 }}
type="text"
onChange={(e) => {
state.val.val1.val2 = e.target.value;
}}
/>
</div>
);
};
describe('test useReactive feature', () => {
it('test count', () => {
const wrap = render(<Demo />);
const count = wrap.getByRole('addCount');
const addCountBtn = wrap.getByRole('addCountBtn');
const subCountBtn = wrap.getByRole('subCountBtn');
act(() => {
fireEvent.click(addCountBtn);
});
expect(count.textContent).toBe('1');
act(() => {
fireEvent.click(addCountBtn);
fireEvent.click(addCountBtn);
});
expect(count.textContent).toBe('3');
act(() => {
fireEvent.click(subCountBtn);
});
expect(count.textContent).toBe('2');
act(() => {
fireEvent.click(subCountBtn);
fireEvent.click(subCountBtn);
fireEvent.click(subCountBtn);
fireEvent.click(subCountBtn);
fireEvent.click(subCountBtn);
});
expect(count.textContent).toBe('-3');
});
it('test array', () => {
const wrap = render(<Demo />);
const testArray = wrap.getByRole('test-array');
const pushbtn = wrap.getByRole('pushbtn');
const popbtn = wrap.getByRole('popbtn');
const shiftbtn = wrap.getByRole('shiftbtn');
const unshiftbtn = wrap.getByRole('unshiftbtn');
act(() => {
fireEvent.click(pushbtn);
});
expect(JSON.parse(testArray.textContent as any).length).toBe(2);
act(() => {
fireEvent.click(popbtn);
});
expect(JSON.parse(testArray.textContent as any).length).toBe(1);
act(() => {
fireEvent.click(unshiftbtn);
});
expect(JSON.parse(testArray.textContent as any).length).toBe(2);
act(() => {
fireEvent.click(shiftbtn);
});
expect(JSON.parse(testArray.textContent as any).length).toBe(1);
});
it('test special objects', () => {
const { result } = renderHook(() => {
// Almost all of the built-in objects are tested.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
return useReactive({
a: new Function('return 1;'),
b: new Boolean(true),
c: Symbol.for('a'),
d: new Error('a'),
e: new Number(1),
f: BigInt(1),
g: Math,
h: new Date(),
i: new String('a'),
j1: new RegExp(/a/),
j2: /a/,
k: new Array(1),
l: new Map(),
m: new Set(),
n: new ArrayBuffer(1),
o: new DataView(new ArrayBuffer(1)),
p: Atomics,
q: JSON,
r: new Promise((resolve) => resolve(1)),
s: Reflect,
t: new Proxy({}, {}),
u: Intl,
v: WebAssembly,
});
});
expect(() => result.current.a.name).not.toThrowError();
expect(() => result.current.b.valueOf()).not.toThrowError();
expect(() => result.current.c.valueOf()).not.toThrowError();
expect(() => result.current.d.message).not.toThrowError();
expect(() => result.current.e.valueOf()).not.toThrowError();
expect(() => result.current.f.valueOf()).not.toThrowError();
expect(() => result.current.g.PI).not.toThrowError();
expect(() => result.current.h.getFullYear()).not.toThrowError();
expect(() => result.current.i.valueOf()).not.toThrowError();
expect(() => result.current.j1.test('a')).not.toThrowError();
expect(() => result.current.j2.test('a')).not.toThrowError();
expect(() => result.current.k.length).not.toThrowError();
expect(() => result.current.l.size).not.toThrowError();
expect(() => result.current.m.size).not.toThrowError();
expect(() => result.current.n.byteLength).not.toThrowError();
expect(() => result.current.o.byteLength).not.toThrowError();
expect(() => result.current.p.isLockFree(1)).not.toThrowError();
expect(() => result.current.q.stringify(1)).not.toThrowError();
expect(() => result.current.r.then()).not.toThrowError();
expect(() => result.current.s.ownKeys({})).not.toThrowError();
expect(() => result.current.t.toString()).not.toThrowError();
expect(() => result.current.u.DateTimeFormat()).not.toThrowError();
expect(() => result.current.v.Module).not.toThrowError();
});
it('test JSX element', () => {
const hook = renderHook(() => useReactive({ html: <div role="id">foo</div> }));
const proxy = hook.result.current;
const wrap = render(proxy.html);
const html = wrap.getByRole('id');
expect(html.textContent).toBe('foo');
act(() => {
proxy.html = <div role="id">bar</div>;
wrap.rerender(proxy.html);
});
expect(html.textContent).toBe('bar');
hook.unmount();
});
it('test read-only and non-configurable data property', () => {
const obj = {} as { user: { name: string } };
Reflect.defineProperty(obj, 'user', {
value: { name: 'foo' },
writable: false,
configurable: false,
});
const hook = renderHook(() => useReactive(obj));
const proxy = hook.result.current;
expect(() => proxy.user.name).not.toThrowError();
hook.unmount();
});
it('test input1', () => {
const wrap = render(<Demo />);
const input = wrap.getByRole('input1');
const inputVal = wrap.getByRole('inputVal1');
act(() => {
fireEvent.change(input, { target: { value: 'a' } });
});
expect(inputVal.textContent).toBe('a');
act(() => {
fireEvent.change(input, { target: { value: 'bbb' } });
});
expect(inputVal.textContent).toBe('bbb');
});
it('delete object property', () => {
const wrap = render(<Demo />);
const deleteProperty = wrap.getByRole('deleteProperty');
const deletePropertyBtn = wrap.getByRole('deletePropertyBtn');
expect(deleteProperty.textContent).toBe('foo');
act(() => {
fireEvent.click(deletePropertyBtn);
});
expect(deleteProperty.textContent).toBe('');
});
it('access from self to prototype chain', () => {
const parent: Record<string, string> = {
name: 'parent',
get value() {
return this.name;
},
};
const child: Record<string, string> = {
name: 'child',
};
const { result } = renderHook(() => useReactive(parent));
const proxy = result.current;
Object.setPrototypeOf(child, proxy);
expect(child.value).toBe('child');
expect(proxy.value).toBe('parent');
expect(parent.value).toBe('parent');
act(() => delete child.name);
expect(child.value).toBe('parent');
expect(proxy.value).toBe('parent');
expect(parent.value).toBe('parent');
act(() => delete proxy.name);
expect(child.value).toBeUndefined();
expect(proxy.value).toBeUndefined();
expect(parent.value).toBeUndefined();
});
});
|
373 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/index.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
describe('useRequest', () => {
beforeAll(() => {
jest.useFakeTimers();
});
afterAll(() => {
errorSpy.mockRestore();
});
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook;
it('useRequest should auto run', async () => {
let value, success;
const successCallback = (text) => {
success = text;
};
const errorCallback = jest.fn();
const beforeCallback = () => {
value = 'before';
};
const finallyCallback = () => {
value = 'finally';
};
//auto run success
act(() => {
hook = setUp(request, {
onSuccess: successCallback,
onError: errorCallback,
onBefore: beforeCallback,
onFinally: finallyCallback,
});
});
expect(hook.result.current.loading).toBe(true);
expect(value).toBe('before');
expect(success).toBeUndefined();
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(success).toBe('success');
expect(hook.result.current.data).toBe('success');
expect(value).toBe('finally');
expect(errorCallback).toHaveBeenCalledTimes(0);
//manual run fail
act(() => {
hook.result.current.run(0);
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.error).toEqual(new Error('fail')));
expect(hook.result.current.loading).toBe(false);
expect(errorCallback).toHaveBeenCalledTimes(1);
//manual run success
act(() => {
hook.result.current.run(1);
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
expect(hook.result.current.data).toBe('success');
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(errorCallback).toHaveBeenCalledTimes(1);
hook.unmount();
//auto run fail
act(() => {
hook = setUp(() => request(0), {
onSuccess: successCallback,
onError: errorCallback,
});
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.error).toEqual(new Error('fail')));
expect(hook.result.current.loading).toBe(false);
expect(errorCallback).toHaveBeenCalledTimes(2);
hook.unmount();
});
it('useRequest should be manually triggered', async () => {
act(() => {
hook = setUp(request, {
manual: true,
});
});
expect(hook.result.current.loading).toBe(false);
act(() => {
hook.result.current.run(1);
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.data).toBe('success');
act(() => {
hook.result.current.run(0);
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.error).toEqual(new Error('fail'));
hook.unmount();
});
it('useRequest runAsync should work', async () => {
let success = '',
error = '';
act(() => {
hook = setUp(request, {
manual: true,
});
});
act(() => {
hook.result.current
.runAsync(0)
.then((res) => {
success = res;
})
.catch((err) => {
error = err;
});
});
act(() => {
jest.runAllTimers();
});
expect(success).toBe('');
await waitFor(() => expect(error).toEqual(new Error('fail')));
success = '';
error = '';
act(() => {
hook.result.current
.runAsync(1)
.then((res) => {
success = res;
})
.catch((err) => {
error = err;
});
});
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(success).toBe('success'));
expect(error).toBe('');
hook.unmount();
});
it('useRequest mutate should work', async () => {
act(() => {
hook = setUp(request, {});
});
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.data).toBe('success'));
act(() => {
hook.result.current.mutate('hello');
});
expect(hook.result.current.data).toBe('hello');
hook.unmount();
});
it('useRequest defaultParams should work', async () => {
act(() => {
hook = setUp(request, {
defaultParams: [1, 2, 3],
});
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
expect(hook.result.current.params).toEqual([1, 2, 3]);
await waitFor(() => expect(hook.result.current.data).toBe('success'));
expect(hook.result.current.loading).toBe(false);
hook.unmount();
});
});
|
374 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/useAutoRunPlugin.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
describe('useAutoRunPlugin', () => {
jest.useFakeTimers();
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook;
it('useAutoRunPlugin ready should work', async () => {
let dep = 1;
act(() => {
hook = setUp(request, {
refreshDeps: [dep],
});
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
dep = 2;
hook.rerender({
refreshDeps: [dep],
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
hook.rerender({
refreshDeps: [dep],
});
expect(hook.result.current.loading).toBe(false);
});
it('useAutoRunPlugin manual=false ready=true work fine', async () => {
act(() => {
hook = setUp(request, {
ready: true,
});
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
hook.rerender({
ready: false,
});
expect(hook.result.current.loading).toBe(false);
hook.rerender({
ready: true,
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
});
it('useAutoRunPlugin manual=false ready=false work fine', async () => {
act(() => {
hook = setUp(request, {
ready: false,
});
});
expect(hook.result.current.loading).toBe(false);
hook.rerender({
ready: true,
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
hook.rerender({
ready: false,
});
expect(hook.result.current.loading).toBe(false);
});
it('useAutoRunPlugin manual=false ready&defaultParams work fine', async () => {
act(() => {
hook = setUp(request, {
ready: false,
defaultParams: [1],
});
});
expect(hook.result.current.loading).toBe(false);
hook.rerender({
ready: true,
defaultParams: [2],
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.params).toEqual([2]);
hook.rerender({
ready: false,
defaultParams: [2],
});
hook.rerender({
ready: true,
defaultParams: [3],
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.params).toEqual([3]);
});
it('useAutoRunPlugin manual=true ready work fine', async () => {
act(() => {
hook = setUp(request, {
ready: false,
manual: true,
});
});
expect(hook.result.current.loading).toBe(false);
act(() => {
hook.result.current.run();
});
expect(hook.result.current.loading).toBe(false);
hook.rerender({
ready: true,
manual: true,
});
expect(hook.result.current.loading).toBe(false);
act(() => {
hook.result.current.run();
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
});
it('useAutoRunPlugin manual=false refreshDeps should work', async () => {
let dep = 1;
act(() => {
hook = setUp(request, {
refreshDeps: [dep],
});
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
dep = 2;
hook.rerender({
refreshDeps: [dep],
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
hook.rerender({
refreshDeps: [dep],
});
expect(hook.result.current.loading).toBe(false);
});
it('useAutoRunPlugin manual=true refreshDeps should work', async () => {
let dep = 1;
act(() => {
hook = setUp(request, {
manual: true,
refreshDeps: [dep],
});
});
expect(hook.result.current.loading).toBe(false);
dep = 2;
hook.rerender({
manual: true,
refreshDeps: [dep],
});
expect(hook.result.current.loading).toBe(false);
});
it('useAutoRunPlugin refreshDepsAction should work', async () => {
let dep = 1;
let count = 0;
const refreshDepsAction = () => {
count += 1;
};
act(() => {
hook = setUp(request, {
refreshDeps: [dep],
refreshDepsAction,
});
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
dep = 2;
hook.rerender({
refreshDeps: [dep],
refreshDepsAction,
});
expect(hook.result.current.loading).toBe(false);
expect(count).toBe(1);
hook.rerender({
refreshDeps: [dep],
refreshDepsAction,
});
expect(hook.result.current.loading).toBe(false);
expect(count).toBe(1);
dep = 3;
hook.rerender({
refreshDeps: [dep],
refreshDepsAction,
});
expect(hook.result.current.loading).toBe(false);
expect(count).toBe(2);
});
it('useAutoRunPlugin ready & refreshDeps change same time work fine', async () => {
const fn = jest.fn();
const asyncFn = () => {
return new Promise((resolve) => {
fn();
return resolve('success');
});
};
act(() => {
hook = setUp(asyncFn, {
ready: false,
defaultParams: [1],
refreshDeps: [1],
});
});
expect(hook.result.current.loading).toBe(false);
hook.rerender({
ready: true,
defaultParams: [2],
refreshDeps: [2],
});
expect(hook.result.current.loading).toBe(true);
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.params).toEqual([2]);
expect(fn).toHaveBeenCalledTimes(1);
});
});
|
375 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/useCachePlugin.test.tsx | import { act, renderHook, waitFor } from '@testing-library/react';
import { render } from '@testing-library/react';
import useRequest, { clearCache } from '../index';
import { request } from '../../utils/testingHelpers';
import React, { useState } from 'react';
import 'jest-localstorage-mock';
describe('useCachePlugin', () => {
jest.useFakeTimers();
const setup = (service, options) => renderHook(() => useRequest(service, options));
const testCacheKey = async (options: any) => {
const hook = setup(request, options);
expect(hook.result.current.loading).toBe(true);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(hook.result.current.loading).toBe(false);
expect(hook.result.current.data).toBe('success');
hook.unmount();
};
it('useRequest cacheKey should work', async () => {
await testCacheKey({
cacheKey: 'testCacheKey',
});
jest.advanceTimersByTime(100);
const hook2 = setup(request, {
cacheKey: 'testCacheKey',
});
expect(hook2.result.current.loading).toBe(true);
expect(hook2.result.current.data).toBe('success');
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(hook2.result.current.loading).toBe(false);
});
it('useRequest staleTime should work', async () => {
await testCacheKey({
cacheKey: 'testStaleTime',
staleTime: 3000,
});
jest.advanceTimersByTime(1000);
const hook2 = setup(request, {
cacheKey: 'testStaleTime',
staleTime: 3000,
});
expect(hook2.result.current.loading).toBe(false);
expect(hook2.result.current.data).toBe('success');
hook2.unmount();
jest.advanceTimersByTime(3001);
const hook3 = setup(request, {
cacheKey: 'testStaleTime',
staleTime: 3000,
});
expect(hook3.result.current.loading).toBe(true);
expect(hook3.result.current.data).toBe('success');
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(hook3.result.current.loading).toBe(false);
});
it('useRequest cacheTime should work', async () => {
await testCacheKey({
cacheKey: 'testCacheTime',
cacheTime: 5000,
});
jest.advanceTimersByTime(1000);
const hook2 = setup(request, {
cacheKey: 'testCacheTime',
cacheTime: 5000,
});
expect(hook2.result.current.loading).toBe(true);
expect(hook2.result.current.data).toBe('success');
hook2.unmount();
jest.advanceTimersByTime(5001);
const hook3 = setup(request, {
cacheKey: 'testCacheTime',
cacheTime: 5000,
});
expect(hook3.result.current.loading).toBe(true);
expect(hook3.result.current.data).toBeUndefined();
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(hook3.result.current.loading).toBe(false);
expect(hook3.result.current.data).toBe('success');
});
it('clearCache should work', async () => {
await testCacheKey('testClearCache');
clearCache('testClearCache');
const hook2 = setup(request, {
cacheKey: 'testClearCache',
});
expect(hook2.result.current.loading).toBe(true);
expect(hook2.result.current.data).toBeUndefined();
});
it('setCache/getCache should work', async () => {
const cacheKey = `setCacheKey`;
await testCacheKey({
cacheKey,
setCache: (data) => localStorage.setItem(cacheKey, JSON.stringify(data)),
getCache: () => JSON.parse(localStorage.getItem(cacheKey) || '{}'),
});
jest.advanceTimersByTime(1000);
const hook2 = setup(request, {
cacheKey,
setCache: (data) => localStorage.setItem(cacheKey, JSON.stringify(data)),
getCache: () => JSON.parse(localStorage.getItem(cacheKey) || '{}'),
});
expect(hook2.result.current.loading).toBe(true);
expect(hook2.result.current.data).toBe('success');
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(hook2.result.current.loading).toBe(false);
});
it('cache should work when change data immediately', async () => {
const { result } = setup(request, {
cacheKey: 'mutateCacheKey',
});
act(() => {
result.current.mutate(1);
});
expect(result.current.data).toBe(1);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(result.current.loading).toBe(false);
expect(result.current.data).toBe('success');
});
//github.com/alibaba/hooks/issues/1859
it('error should reset with activeKey', async () => {
const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
let res = {} as any;
const TestComponent = () => {
const [key, setKey] = useState<number>(1);
const { data, error } = useRequest(() => request(key), {
refreshDeps: [key],
cacheKey: String(key),
staleTime: 300000,
});
res = {
data,
error,
setKey,
};
return null;
};
render(<TestComponent />);
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(res.error).toBeUndefined();
act(() => res.setKey(0));
await act(async () => {
jest.advanceTimersByTime(1000);
});
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(errSpy).toBeCalled();
await waitFor(() => expect(res.error).not.toBeUndefined());
act(() => res.setKey(1));
await act(async () => {
jest.advanceTimersByTime(1000);
});
expect(res.error).toBeUndefined();
errSpy.mockRestore();
});
});
|
376 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/useDebouncePlugin.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
describe('useDebouncePlugin', () => {
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook;
it('useDebouncePlugin should work', async () => {
jest.useFakeTimers();
const callback = jest.fn();
act(() => {
hook = setUp(
() => {
callback();
return request({});
},
{
manual: true,
debounceWait: 100,
},
);
});
act(() => {
hook.result.current.run(1);
jest.advanceTimersByTime(50);
hook.result.current.run(2);
jest.advanceTimersByTime(50);
hook.result.current.run(3);
jest.advanceTimersByTime(50);
hook.result.current.run(4);
});
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(callback).toHaveBeenCalledTimes(1));
act(() => {
hook.result.current.run(1);
jest.advanceTimersByTime(50);
hook.result.current.run(2);
jest.advanceTimersByTime(50);
hook.result.current.run(3);
jest.advanceTimersByTime(50);
hook.result.current.run(4);
});
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(callback).toHaveBeenCalledTimes(2));
act(() => {
hook.result.current.run(1);
jest.advanceTimersByTime(50);
hook.result.current.run(2);
jest.advanceTimersByTime(50);
hook.result.current.cancel();
});
act(() => {
jest.runAllTimers();
});
expect(callback).toHaveBeenCalledTimes(2);
hook.unmount();
});
});
|
377 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/useLoadingDelayPlugin.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import type { RenderHookResult } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
describe('useLoadingDelayPlugin', () => {
jest.useFakeTimers();
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook: RenderHookResult<ReturnType<typeof useRequest>, any>;
afterEach(() => {
hook.unmount();
});
it('useLoadingDelayPlugin should work', async () => {
act(() => {
hook = setUp(request, {
loadingDelay: 2000,
});
});
expect(hook.result.current.loading).toBe(false);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
act(() => {
hook = setUp(request, {
loadingDelay: 500,
});
});
expect(hook.result.current.loading).toBe(false);
act(() => {
jest.advanceTimersByTime(501);
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.loading).toBe(false);
});
it('useLoadingDelayPlugin should no update loading when ready is false', async () => {
act(() => {
hook = setUp(request, {
loadingDelay: 2000,
ready: false,
});
});
expect(hook.result.current.loading).toBe(false);
act(() => {
jest.advanceTimersByTime(3000);
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
});
it('useLoadingDelayPlugin should update loading when ready is undefined', async () => {
act(() => {
hook = setUp(request, {
loadingDelay: 2000,
});
});
expect(hook.result.current.loading).toBe(false);
act(() => {
jest.advanceTimersByTime(3000);
});
await waitFor(() => expect(hook.result.current.loading).toBe(true));
});
});
|
378 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/usePollingPlugin.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
describe('usePollingPlugin', () => {
jest.useFakeTimers();
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook;
it('usePollingPlugin pollingInterval=100 pollingWhenHidden=true should work', async () => {
const callback = jest.fn();
act(() => {
hook = setUp(
() => {
callback();
return request(1);
},
{
pollingInterval: 100,
pollingWhenHidden: true,
},
);
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
expect(hook.result.current.data).toBe('success');
expect(callback).toHaveBeenCalledTimes(1);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(callback).toHaveBeenCalledTimes(2));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(callback).toHaveBeenCalledTimes(3));
act(() => {
hook.result.current.cancel();
});
act(() => {
jest.runAllTimers();
});
expect(callback).toHaveBeenCalledTimes(3);
act(() => {
hook.result.current.run();
});
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(callback).toHaveBeenCalledTimes(4));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(callback).toHaveBeenCalledTimes(5));
});
let hook2;
it('usePollingPlugin pollingErrorRetryCount=3 should work', async () => {
// if request error and set pollingErrorRetryCount
// and the number of consecutive failures exceeds pollingErrorRetryCount, polling stops
let errorCallback;
act(() => {
errorCallback = jest.fn();
hook2 = setUp(() => request(0), {
pollingErrorRetryCount: 3,
pollingInterval: 100,
pollingWhenHidden: true,
onError: errorCallback,
});
});
expect(hook2.result.current.loading).toBe(true);
expect(errorCallback).toHaveBeenCalledTimes(0);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(hook2.result.current.loading).toBe(false));
expect(errorCallback).toHaveBeenCalledTimes(1);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(2));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(3));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(4));
act(() => {
jest.runAllTimers();
});
expect(errorCallback).toHaveBeenCalledTimes(4);
act(() => {
hook2.result.current.run();
});
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(5));
});
});
|
379 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/useRefreshOnWindowFocusPlugin.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import { fireEvent } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
describe('useRefreshOnWindowFocusPlugin', () => {
jest.useFakeTimers();
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook;
it('useRefreshOnWindowFocusPlugin should work', async () => {
act(() => {
hook = setUp(request, {
refreshOnWindowFocus: true,
focusTimespan: 5000,
});
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.advanceTimersByTime(1001);
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
act(() => {
fireEvent.focus(window);
});
expect(hook.result.current.loading).toBe(true);
act(() => {
jest.advanceTimersByTime(2000);
});
await waitFor(() => expect(hook.result.current.loading).toBe(false));
act(() => {
jest.advanceTimersByTime(3000);
fireEvent.focus(window);
});
expect(hook.result.current.loading).toBe(true);
});
it('fix: multiple unsubscriptions should not delete the last subscription listener ', async () => {
let hook1;
let hook2;
act(() => {
hook1 = setUp(request, {
refreshOnWindowFocus: true,
});
hook2 = setUp(request, {
refreshOnWindowFocus: true,
});
});
expect(hook1.result.current.loading).toBe(true);
expect(hook2.result.current.loading).toBe(true);
act(() => {
jest.advanceTimersByTime(1001);
});
await waitFor(() => expect(hook1.result.current.loading).toBe(false));
expect(hook2.result.current.loading).toBe(false);
act(() => {
fireEvent.focus(window);
});
expect(hook1.result.current.loading).toBe(true);
expect(hook2.result.current.loading).toBe(true);
act(() => {
jest.advanceTimersByTime(2000);
});
await waitFor(() => expect(hook1.result.current.loading).toBe(false));
expect(hook2.result.current.loading).toBe(false);
hook1.unmount();
act(() => {
jest.advanceTimersByTime(3000);
fireEvent.focus(window);
});
expect(hook1.result.current.loading).toBe(false);
// hook2 should not unsubscribe
expect(hook2.result.current.loading).toBe(true);
});
});
|
380 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/useRetryPlugin.test.ts | import { act, renderHook, waitFor } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
describe('useRetryPlugin', () => {
jest.useFakeTimers();
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook;
it('useRetryPlugin should work', async () => {
let errorCallback;
act(() => {
errorCallback = jest.fn();
hook = setUp(() => request(0), {
retryCount: 3,
onError: errorCallback,
});
});
act(() => {
jest.setTimeout(10000);
jest.advanceTimersByTime(500);
});
expect(errorCallback).toHaveBeenCalledTimes(0);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(1));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(2));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(3));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(4));
act(() => {
jest.runAllTimers();
});
expect(errorCallback).toHaveBeenCalledTimes(4);
hook.unmount();
//cancel should work
let hook2;
act(() => {
errorCallback = jest.fn();
hook2 = setUp(() => request(0), {
retryCount: 3,
onError: errorCallback,
});
});
expect(errorCallback).toHaveBeenCalledTimes(0);
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(1));
act(() => {
jest.runAllTimers();
});
await waitFor(() => expect(errorCallback).toHaveBeenCalledTimes(2));
act(() => {
hook2.result.current.cancel();
});
act(() => {
jest.runAllTimers();
});
expect(errorCallback).toHaveBeenCalledTimes(2);
hook2.unmount();
});
});
|
381 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest | petrpan-code/alibaba/hooks/packages/hooks/src/useRequest/__tests__/useThrottlePlugin.test.ts | import { act, renderHook } from '@testing-library/react';
import useRequest from '../index';
import { request } from '../../utils/testingHelpers';
describe('useThrottlePlugin', () => {
jest.useFakeTimers();
const setUp = (service, options) => renderHook((o) => useRequest(service, o || options));
let hook;
it('useThrottlePlugin should work', async () => {
const callback = jest.fn();
act(() => {
hook = setUp(
() => {
callback();
return request({});
},
{
manual: true,
throttleWait: 100,
},
);
});
act(() => {
hook.result.current.run(1);
jest.advanceTimersByTime(50);
hook.result.current.run(2);
jest.advanceTimersByTime(50);
hook.result.current.run(3);
jest.advanceTimersByTime(50);
hook.result.current.run(4);
jest.advanceTimersByTime(40);
});
expect(callback).toHaveBeenCalledTimes(2);
});
});
|
454 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useResetState | petrpan-code/alibaba/hooks/packages/hooks/src/useResetState/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useResetState from '../index';
describe('useResetState', () => {
const setUp = <S>(initialState: S) =>
renderHook(() => {
const [state, setState, resetState] = useResetState<S>(initialState);
return {
state,
setState,
resetState,
} as const;
});
it('should support initialValue', () => {
const hook = setUp({
hello: 'world',
});
expect(hook.result.current.state).toEqual({ hello: 'world' });
});
it('should reset state', () => {
const hook = setUp({
hello: '',
count: 0,
});
act(() => {
hook.result.current.setState({
hello: 'world',
count: 1,
});
});
act(() => {
hook.result.current.resetState();
});
expect(hook.result.current.state).toEqual({ hello: '', count: 0 });
});
it('should support function update', () => {
const hook = setUp({
count: 0,
});
act(() => {
hook.result.current.setState((prev) => ({ count: prev.count + 1 }));
});
expect(hook.result.current.state).toEqual({ count: 1 });
});
});
|
459 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useResponsive | petrpan-code/alibaba/hooks/packages/hooks/src/useResponsive/__tests__/index.test.ts | import { renderHook, act } from '../../utils/tests';
import { useResponsive } from '../';
describe('useResponsive', () => {
function changeWidth(width: number) {
act(() => {
(global as any).innerWidth = width;
(global as any).dispatchEvent(new Event('resize'));
});
}
changeWidth(1024);
const hook = renderHook(() => useResponsive());
it('should response to window width changes', () => {
expect(hook.result.current).toMatchSnapshot();
changeWidth(300);
expect(hook.result.current).toMatchSnapshot();
changeWidth(700);
expect(hook.result.current).toMatchSnapshot();
changeWidth(800);
expect(hook.result.current).toMatchSnapshot();
changeWidth(1000);
expect(hook.result.current).toMatchSnapshot();
changeWidth(1200);
expect(hook.result.current).toMatchSnapshot();
});
});
|
460 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useResponsive/__tests__ | petrpan-code/alibaba/hooks/packages/hooks/src/useResponsive/__tests__/__snapshots__/index.test.ts.snap | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`useResponsive should response to window width changes 1`] = `
{
"lg": true,
"md": true,
"sm": true,
"xl": false,
"xs": true,
}
`;
exports[`useResponsive should response to window width changes 2`] = `
{
"lg": false,
"md": false,
"sm": false,
"xl": false,
"xs": true,
}
`;
exports[`useResponsive should response to window width changes 3`] = `
{
"lg": false,
"md": false,
"sm": true,
"xl": false,
"xs": true,
}
`;
exports[`useResponsive should response to window width changes 4`] = `
{
"lg": false,
"md": true,
"sm": true,
"xl": false,
"xs": true,
}
`;
exports[`useResponsive should response to window width changes 5`] = `
{
"lg": true,
"md": true,
"sm": true,
"xl": false,
"xs": true,
}
`;
exports[`useResponsive should response to window width changes 6`] = `
{
"lg": true,
"md": true,
"sm": true,
"xl": true,
"xs": true,
}
`;
|
465 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useSafeState | petrpan-code/alibaba/hooks/packages/hooks/src/useSafeState/__tests__/index.test.ts | import { act, renderHook, RenderHookResult } from '@testing-library/react';
import useSafeState from '../index';
describe('useSetState', () => {
const setUp = (initialValue: any) =>
renderHook(() => {
const [state, setState] = useSafeState(initialValue);
return {
state,
setState,
} as const;
});
it('should support initialValue', () => {
const hook = setUp({
hello: 'world',
});
expect(hook.result.current.state).toEqual({ hello: 'world' });
});
it('should support update', () => {
const hook = setUp(0);
act(() => {
hook.result.current.setState(5);
});
expect(hook.result.current.state).toBe(5);
});
it('should not support update when unmount', () => {
const hook = setUp(0);
hook.unmount();
act(() => {
hook.result.current.setState(5);
});
expect(hook.result.current.state).toBe(0);
});
});
|
470 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useScroll | petrpan-code/alibaba/hooks/packages/hooks/src/useScroll/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useScroll from '../index';
describe('useScroll', () => {
it('document body', () => {
const hook = renderHook(() => useScroll(document));
expect(hook.result.current).toBeUndefined();
});
});
|
477 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useSelections | petrpan-code/alibaba/hooks/packages/hooks/src/useSelections/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useSelections from '../index';
const data = [1, 2, 3];
const setup = <T>(items: T[], defaultSelected?: T[]) => {
return renderHook(() => useSelections(items, defaultSelected));
};
describe('useSelections', () => {
it('defaultSelected should work correct', () => {
const { result } = setup(data, [1]);
expect(result.current.selected).toEqual([1]);
expect(result.current.isSelected(1)).toBe(true);
});
it('select and unSelect should work correct', () => {
const { result } = setup(data, [1]);
const { unSelect, select } = result.current;
act(() => {
unSelect(1);
});
expect(result.current.selected).toEqual([]);
expect(result.current.isSelected(1)).toBe(false);
expect(result.current.allSelected).toBe(false);
act(() => {
select(1);
});
expect(result.current.selected).toEqual([1]);
expect(result.current.isSelected(1)).toBe(true);
expect(result.current.allSelected).toBe(false);
});
it('toggle should work correct', () => {
const { result } = setup(data);
const { toggle } = result.current;
act(() => {
toggle(1);
});
expect(result.current.selected).toEqual([1]);
expect(result.current.isSelected(1)).toBe(true);
expect(result.current.allSelected).toBe(false);
act(() => {
toggle(1);
});
expect(result.current.selected).toEqual([]);
expect(result.current.isSelected(1)).toBe(false);
expect(result.current.allSelected).toBe(false);
});
it('selectAll and unSelectAll should work correct', async () => {
const { result } = setup(data);
const { selectAll, unSelectAll } = result.current;
expect(result.current.noneSelected).toBe(true);
act(() => {
selectAll();
});
expect(result.current.selected).toEqual([1, 2, 3]);
expect(result.current.allSelected).toBe(true);
expect(result.current.noneSelected).toBe(false);
expect(result.current.partiallySelected).toBe(false);
act(() => {
unSelectAll();
});
expect(result.current.selected).toEqual([]);
expect(result.current.allSelected).toBe(false);
expect(result.current.noneSelected).toBe(true);
expect(result.current.partiallySelected).toBe(false);
});
it('toggleAll should work correct', async () => {
const { result } = setup(data);
const { toggleAll } = result.current;
expect(result.current.noneSelected).toBe(true);
act(() => {
toggleAll();
});
expect(result.current.selected).toEqual([1, 2, 3]);
expect(result.current.allSelected).toBe(true);
expect(result.current.noneSelected).toBe(false);
expect(result.current.partiallySelected).toBe(false);
act(() => {
toggleAll();
});
expect(result.current.selected).toEqual([]);
expect(result.current.allSelected).toBe(false);
expect(result.current.noneSelected).toBe(true);
expect(result.current.partiallySelected).toBe(false);
});
it('setSelected should work correct', async () => {
const { result } = setup(data);
const { setSelected } = result.current;
expect(result.current.noneSelected).toBe(true);
act(() => {
setSelected([1]);
});
expect(result.current.selected).toEqual([1]);
expect(result.current.isSelected(1)).toBe(true);
expect(result.current.noneSelected).toBe(false);
expect(result.current.allSelected).toBe(false);
expect(result.current.partiallySelected).toBe(true);
act(() => {
setSelected([]);
});
expect(result.current.selected).toEqual([]);
expect(result.current.isSelected(1)).toBe(false);
expect(result.current.noneSelected).toBe(true);
expect(result.current.allSelected).toBe(false);
expect(result.current.partiallySelected).toBe(false);
act(() => {
setSelected([1, 2, 3]);
});
expect(result.current.selected).toEqual([1, 2, 3]);
expect(result.current.isSelected(1)).toBe(true);
expect(result.current.noneSelected).toBe(false);
expect(result.current.allSelected).toBe(true);
expect(result.current.partiallySelected).toBe(false);
});
});
|
482 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useSessionStorageState | petrpan-code/alibaba/hooks/packages/hooks/src/useSessionStorageState/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useSessionStorageState from '../index';
describe('useSessionStorageState', () => {
const setUp = <T>(key: string, value: T) =>
renderHook(() => {
const [state, setState] = useSessionStorageState<T>(key, { defaultValue: value });
return {
state,
setState,
} as const;
});
it('should support object', () => {
const LOCAL_STORAGE_KEY = 'test-object-key';
const hook = setUp<{ name: string }>(LOCAL_STORAGE_KEY, {
name: 'A',
});
expect(hook.result.current.state).toEqual({ name: 'A' });
act(() => {
hook.result.current.setState({ name: 'B' });
});
expect(hook.result.current.state).toEqual({ name: 'B' });
const anotherHook = setUp(LOCAL_STORAGE_KEY, {
name: 'C',
});
expect(anotherHook.result.current.state).toEqual({ name: 'B' });
act(() => {
anotherHook.result.current.setState({
name: 'C',
});
});
expect(anotherHook.result.current.state).toEqual({ name: 'C' });
expect(hook.result.current.state).toEqual({ name: 'B' });
});
it('should support function updater', () => {
const LOCAL_STORAGE_KEY = 'test-func-updater';
const hook = setUp<string | null>(LOCAL_STORAGE_KEY, 'hello world');
expect(hook.result.current.state).toBe('hello world');
act(() => {
hook.result.current.setState((state) => `${state}, zhangsan`);
});
expect(hook.result.current.state).toBe('hello world, zhangsan');
});
});
|
486 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useSet | petrpan-code/alibaba/hooks/packages/hooks/src/useSet/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useSet from '../index';
const setUp = <K>(initialSet?: Iterable<K>) => renderHook(() => useSet(initialSet));
describe('useSet', () => {
it('should init set and utils', () => {
const { result } = setUp([1, 2]);
const [set, utils] = result.current;
expect(set).toEqual(new Set([1, 2]));
expect(utils).toStrictEqual({
add: expect.any(Function),
remove: expect.any(Function),
reset: expect.any(Function),
});
});
it('should init empty set if no initial set provided', () => {
const { result } = setUp();
expect(result.current[0]).toEqual(new Set());
const { result: result1 } = setUp(undefined);
expect(result1.current[0]).toEqual(new Set());
});
it('should have an initially provided key', () => {
const { result } = setUp(['a']);
const [set, utils] = result.current;
let value;
act(() => {
value = set.has('a');
});
expect(value).toBe(true);
});
it('should have an added key', () => {
const { result } = setUp();
act(() => {
result.current[1].add('newKey');
});
let value;
act(() => {
value = result.current[0].has('newKey');
});
expect(value).toBe(true);
});
it('should get false for non-existing key', () => {
const { result } = setUp(['a']);
const [set] = result.current;
let value;
act(() => {
value = set.has('nonExisting');
});
expect(value).toBe(false);
});
it('should add a new key', () => {
const { result } = setUp(['oldKey']);
const [, utils] = result.current;
act(() => {
utils.add('newKey');
});
expect(result.current[0]).toEqual(new Set(['oldKey', 'newKey']));
});
it('should work if setting existing key', () => {
const { result } = setUp(['oldKey']);
const [, utils] = result.current;
act(() => {
utils.add('oldKey');
});
expect(result.current[0]).toEqual(new Set(['oldKey']));
});
it('should remove existing key', () => {
const { result } = setUp([1, 2]);
const [, utils] = result.current;
act(() => {
utils.remove(2);
});
expect(result.current[0]).toEqual(new Set([1]));
});
it('should do nothing if removing non-existing key', () => {
const { result } = setUp(['a', 'b']);
const [, utils] = result.current;
act(() => {
utils.remove('nonExisting');
});
expect(result.current[0]).toEqual(new Set(['a', 'b']));
});
it('should reset to initial set provided', () => {
const { result } = setUp([1]);
const [, utils] = result.current;
act(() => {
utils.add(2);
});
expect(result.current[0]).toEqual(new Set([1, 2]));
act(() => {
utils.reset();
});
expect(result.current[0]).toEqual(new Set([1]));
});
it('should memoized its utils methods', () => {
const { result } = setUp(['a', 'b']);
const [, utils] = result.current;
const { add, remove, reset } = utils;
act(() => {
add('foo');
});
expect(result.current[1].add).toBe(add);
expect(result.current[1].remove).toBe(remove);
expect(result.current[1].reset).toBe(reset);
});
});
|
491 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useSetState | petrpan-code/alibaba/hooks/packages/hooks/src/useSetState/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useSetState from '../index';
describe('useSetState', () => {
const setUp = <T extends object>(initialValue: T) =>
renderHook(() => {
const [state, setState] = useSetState<T>(initialValue);
return {
state,
setState,
} as const;
});
it('should support initialValue', () => {
const hook = setUp({
hello: 'world',
});
expect(hook.result.current.state).toEqual({ hello: 'world' });
});
it('should support object', () => {
const hook = setUp<any>({
hello: 'world',
});
act(() => {
hook.result.current.setState({ foo: 'bar' });
});
expect(hook.result.current.state).toEqual({ hello: 'world', foo: 'bar' });
});
it('should support function update', () => {
const hook = setUp({
count: 0,
});
act(() => {
hook.result.current.setState((prev) => ({ count: prev.count + 1 }));
});
expect(hook.result.current.state).toEqual({ count: 1 });
});
});
|
497 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useSize | petrpan-code/alibaba/hooks/packages/hooks/src/useSize/__tests__/index.test.tsx | import React, { useRef } from 'react';
import { renderHook, act, render, screen } from '@testing-library/react';
import useSize from '../index';
let callback;
jest.mock('resize-observer-polyfill', () => {
return jest.fn().mockImplementation((cb) => {
callback = cb;
return {
observe: () => {},
disconnect: () => {},
};
});
});
// test about Resize Observer see https://github.com/que-etc/resize-observer-polyfill/tree/master/tests
describe('useSize', () => {
it('should work when target is a mounted DOM', () => {
const hook = renderHook(() => useSize(document.body));
expect(hook.result.current).toEqual({ height: 0, width: 0 });
});
it('should work when target is a `MutableRefObject`', async () => {
const mockRaf = jest
.spyOn(window, 'requestAnimationFrame')
.mockImplementation((cb: FrameRequestCallback) => {
cb(0);
return 0;
});
function Setup() {
const ref = useRef(null);
const size = useSize(ref);
return (
<div ref={ref}>
<div>width: {String(size?.width)}</div>
<div>height: {String(size?.height)}</div>
</div>
);
}
render(<Setup />);
expect(await screen.findByText(/^width/)).toHaveTextContent('width: undefined');
expect(await screen.findByText(/^height/)).toHaveTextContent('height: undefined');
act(() => callback([{ target: { clientWidth: 10, clientHeight: 10 } }]));
expect(await screen.findByText(/^width/)).toHaveTextContent('width: 10');
expect(await screen.findByText(/^height/)).toHaveTextContent('height: 10');
mockRaf.mockRestore();
});
it('should not work when target is null', () => {
expect(() => {
renderHook(() => useSize(null));
}).not.toThrowError();
});
it('should work', () => {
const mockRaf = jest
.spyOn(window, 'requestAnimationFrame')
.mockImplementation((cb: FrameRequestCallback) => {
cb(0);
return 0;
});
const targetEl = document.createElement('div');
const { result } = renderHook(() => useSize(targetEl));
act(() => {
callback([
{
target: {
clientWidth: 100,
clientHeight: 50,
},
},
]);
});
expect(result.current).toMatchObject({
width: 100,
height: 50,
});
mockRaf.mockRestore();
});
});
|
503 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useTextSelection | petrpan-code/alibaba/hooks/packages/hooks/src/useTextSelection/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useTextSelection from '../index';
// test about Resize Observer see https://github.com/que-etc/resize-observer-polyfill/tree/master/tests
describe('useTextSelection', () => {
function moveMouse(x: number, y: number) {
act(() => {
document.dispatchEvent(
new MouseEvent('mousemove', {
clientX: x,
clientY: y,
screenX: x,
screenY: y,
}),
);
});
}
function downMouse(x: number, y: number, options?: MouseEventInit) {
act(() => {
document.dispatchEvent(
new MouseEvent('mousedown', {
clientX: x,
clientY: y,
screenX: x,
screenY: y,
...options,
}),
);
});
}
function upMouse(x: number, y: number) {
act(() => {
document.dispatchEvent(
new MouseEvent('mouseup', {
clientX: x,
clientY: y,
screenX: x,
screenY: y,
}),
);
});
}
function initGetSelection({ top = 0, left = 0, height = 0, width = 0, text = 'hello world!' }) {
// TODO
// @ts-ignore
window.getSelection = () => {
return {
toString: () => {
return text;
},
rangeCount: text.length,
removeAllRanges: () => {},
getRangeAt: (index: number) => {
return {
getBoundingClientRect: () => {
return {
top,
left,
bottom: top + height,
right: left + width,
height,
width,
};
},
};
},
};
};
}
it('on textSelection', async () => {
initGetSelection({ left: 10, top: 10, height: 100, width: 100, text: 'on textSelection' });
// TODO
// @ts-ignore
const hook = renderHook(() => useTextSelection(() => document));
expect(hook.result.current.text).toBe('');
expect(hook.result.current.left).toBeNaN();
expect(hook.result.current.right).toBeNaN();
expect(hook.result.current.top).toBeNaN();
expect(hook.result.current.bottom).toBeNaN();
expect(hook.result.current.height).toBeNaN();
expect(hook.result.current.width).toBeNaN();
downMouse(0, 0);
upMouse(100, 100);
expect(hook.result.current.left).toBe(10);
expect(hook.result.current.text).toBe('on textSelection');
hook.unmount();
});
it('keep/cancel the selected text range', async () => {
initGetSelection({ text: 'aaa' });
const hook = renderHook(() => useTextSelection(() => document));
expect(hook.result.current.text).toBe('');
downMouse(0, 0);
upMouse(100, 100);
expect(hook.result.current.text).toBe('aaa');
// trigger the secondary button of mouse (usually the right button)
downMouse(0, 0, { button: 2 });
expect(hook.result.current.text).toBe('aaa');
// // trigger the main button of mouse (usually the left button)
downMouse(0, 0, { button: 0 });
expect(hook.result.current.text).toBe('');
hook.unmount();
});
});
|
511 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useThrottle | petrpan-code/alibaba/hooks/packages/hooks/src/useThrottle/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useThrottle from '../index';
import { sleep } from '../../utils/testingHelpers';
let hook;
describe('useThrottle', () => {
it('default useThrottle should work', async () => {
let mountedState = 1;
act(() => {
hook = renderHook(() => useThrottle(mountedState, { wait: 500 }));
});
expect(hook.result.current).toBe(1);
mountedState = 2;
hook.rerender();
mountedState = 3;
hook.rerender();
await act(async () => {
await sleep(250);
});
expect(hook.result.current).toBe(1);
mountedState = 4;
hook.rerender();
await act(async () => {
await sleep(260);
});
expect(hook.result.current).toBe(4);
});
it('leading:false & trailing:false of options useThrottle should work', async () => {
let mountedState = 0;
act(() => {
hook = renderHook(() =>
useThrottle(mountedState, { wait: 500, leading: false, trailing: false }),
);
});
//Never get the latest value
mountedState = 1;
expect(hook.result.current).toBe(0);
mountedState = 2;
hook.rerender();
mountedState = 3;
hook.rerender();
await sleep(250);
expect(hook.result.current).toBe(0);
mountedState = 4;
hook.rerender();
await sleep(260);
expect(hook.result.current).toBe(0);
});
it('leading:true & trailing:false of options useThrottle should work', async () => {
let mountedState = 0;
act(() => {
hook = renderHook(() =>
useThrottle(mountedState, { wait: 500, leading: true, trailing: false }),
);
});
expect(hook.result.current).toBe(0);
mountedState = 1;
hook.rerender();
await sleep(0);
expect(hook.result.current).toBe(0);
mountedState = 2;
await sleep(200);
hook.rerender();
await sleep(0);
expect(hook.result.current).toBe(0);
mountedState = 3;
//Need to wait more than 500ms to get the latest value
await act(async () => {
await sleep(300);
});
hook.rerender();
await sleep(0);
expect(hook.result.current).toBe(3);
});
it('leading:false & trailing:true of options useThrottle should work', async () => {
let mountedState = 0;
act(() => {
hook = renderHook(() =>
useThrottle(mountedState, { wait: 500, leading: false, trailing: true }),
);
});
expect(hook.result.current).toBe(0);
mountedState = 1;
hook.rerender();
await sleep(0);
expect(hook.result.current).toBe(0);
mountedState = 2;
hook.rerender();
await sleep(250);
expect(hook.result.current).toBe(0);
mountedState = 3;
hook.rerender();
await act(async () => {
await sleep(260);
});
await sleep(260);
expect(hook.result.current).toBe(3);
});
});
|
516 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useThrottleEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useThrottleEffect/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useThrottleEffect from '../index';
import { sleep } from '../../utils/testingHelpers';
let hook;
describe('useThrottleEffect', () => {
it('useThrottleEffect should work', async () => {
const mockEffect = jest.fn(() => {});
const mockCleanUp = jest.fn(() => {});
act(() => {
hook = renderHook(
({ value, wait }) =>
useThrottleEffect(
() => {
mockEffect();
return () => {
mockCleanUp();
};
},
[value],
{ wait },
),
{ initialProps: { value: 1, wait: 200 } },
);
});
hook.rerender({ value: 2, wait: 200 });
await sleep(100);
expect(mockEffect.mock.calls.length).toBe(1);
expect(mockCleanUp.mock.calls.length).toBe(0);
await act(async () => {
await sleep(150);
});
expect(mockEffect.mock.calls.length).toBe(2);
expect(mockCleanUp.mock.calls.length).toBe(1);
hook.rerender({ value: 3, wait: 100 });
await sleep(50);
expect(mockEffect.mock.calls.length).toBe(3);
expect(mockCleanUp.mock.calls.length).toBe(2);
await act(async () => {
await sleep(100);
});
expect(mockEffect.mock.calls.length).toBe(3);
expect(mockCleanUp.mock.calls.length).toBe(2);
});
it('should cancel timeout on unmount', async () => {
const mockEffect = jest.fn(() => {});
const mockCleanUp = jest.fn(() => {});
const hook = renderHook(
(props) =>
useThrottleEffect(
() => {
mockEffect();
return () => {
mockCleanUp();
};
},
[props],
{ wait: 200 },
),
{ initialProps: 0 },
);
await act(async () => {
expect(mockEffect.mock.calls.length).toBe(1);
expect(mockCleanUp.mock.calls.length).toBe(0);
hook.rerender(1);
await sleep(50);
hook.unmount();
expect(mockEffect.mock.calls.length).toBe(1);
expect(mockCleanUp.mock.calls.length).toBe(1);
});
});
});
|
521 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useThrottleFn | petrpan-code/alibaba/hooks/packages/hooks/src/useThrottleFn/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useThrottleFn from '../index';
import { sleep } from '../../utils/testingHelpers';
interface ParamsObj {
fn: (...arg: any) => any;
deps?: any[];
wait: number;
}
const setUp = ({ fn, wait }: ParamsObj) => renderHook(() => useThrottleFn(fn, { wait }));
let hook;
describe('useThrottleFn', () => {
it('run, cancel and flush should work', async () => {
let count = 0;
const throttleFn = (gap: number) => {
count += gap;
};
act(() => {
hook = setUp({
fn: throttleFn,
wait: 500,
});
});
await act(async () => {
hook.result.current.run(1);
expect(count).toBe(1);
hook.result.current.run(1);
hook.result.current.run(1);
hook.result.current.run(1);
expect(count).toBe(1);
await sleep(450); // t: 450
hook.result.current.run(2);
expect(count).toBe(1);
await sleep(100); // t: 550
hook.result.current.run(2);
expect(count).toBe(3);
hook.result.current.run(3);
hook.result.current.run(3);
await sleep(500); // t: 1050
expect(count).toBe(6);
hook.result.current.run(1);
hook.result.current.run(4);
hook.result.current.cancel();
await sleep(500); // t: 1550
expect(count).toBe(7);
hook.result.current.run(1);
hook.result.current.run(1);
expect(count).toBe(8);
hook.result.current.flush();
expect(count).toBe(9);
await sleep(550); // t: 2100
expect(count).toBe(9);
});
});
// it('should output error when fn is not a function', () => {
// const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
// renderHook(() => useThrottleFn(1 as any));
// expect(errSpy).toBeCalledWith('useThrottleFn expected parameter is a function, got number');
// errSpy.mockRestore();
// });
});
|
526 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useTimeout | petrpan-code/alibaba/hooks/packages/hooks/src/useTimeout/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useTimeout from '../index';
interface ParamsObj {
fn: (...arg: any) => any;
delay: number | undefined;
}
const setUp = ({ fn, delay }: ParamsObj) => renderHook(() => useTimeout(fn, delay));
describe('useTimeout', () => {
jest.useFakeTimers();
jest.spyOn(global, 'clearTimeout');
it('timeout should work', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: 20 });
expect(callback).not.toBeCalled();
jest.advanceTimersByTime(70);
expect(callback).toHaveBeenCalledTimes(1);
});
it('timeout should stop', () => {
const callback = jest.fn();
setUp({ fn: callback, delay: undefined });
jest.advanceTimersByTime(50);
expect(callback).toHaveBeenCalledTimes(0);
setUp({ fn: callback, delay: -2 });
jest.advanceTimersByTime(50);
expect(callback).toHaveBeenCalledTimes(0);
});
it('timeout should be clear', () => {
const callback = jest.fn();
const hook = setUp({ fn: callback, delay: 20 });
expect(callback).not.toBeCalled();
hook.result.current();
jest.advanceTimersByTime(30);
expect(callback).toHaveBeenCalledTimes(0);
expect(clearTimeout).toHaveBeenCalledTimes(1);
});
});
|
532 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useTitle | petrpan-code/alibaba/hooks/packages/hooks/src/useTitle/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useTitle from '../index';
describe('useTitle', () => {
it('should update document title', () => {
const hook = renderHook((props) => useTitle(props), { initialProps: 'Current Page Title' });
expect(document.title).toBe('Current Page Title');
act(() => {
hook.rerender('Other Page Title');
});
expect(document.title).toBe('Other Page Title');
});
it('should restore document title on unmount', () => {
document.title = 'Old Title';
const hook = renderHook((props) => useTitle(props, { restoreOnUnmount: true }), {
initialProps: 'Current Page Title',
});
expect(document.title).toBe('Current Page Title');
hook.unmount();
expect(document.title).toBe('Old Title');
});
it('should not restore document title on unmount', () => {
document.title = 'Old Title';
const hook = renderHook((props) => useTitle(props, { restoreOnUnmount: false }), {
initialProps: 'Current Page Title',
});
expect(document.title).toBe('Current Page Title');
hook.unmount();
expect(document.title).toBe('Current Page Title');
});
});
|
537 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useToggle | petrpan-code/alibaba/hooks/packages/hooks/src/useToggle/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useToggle from '../index';
const callToggle = (hook: any) => {
act(() => {
hook.result.current[1].toggle();
});
};
describe('useToggle', () => {
it('test on init', async () => {
const hook = renderHook(() => useToggle());
expect(hook.result.current[0]).toBeFalsy();
});
it('test on methods', async () => {
const hook = renderHook(() => useToggle('Hello'));
expect(hook.result.current[0]).toBe('Hello');
callToggle(hook);
expect(hook.result.current[0]).toBeFalsy();
act(() => {
hook.result.current[1].setLeft();
});
expect(hook.result.current[0]).toBe('Hello');
act(() => {
hook.result.current[1].setRight();
});
expect(hook.result.current[0]).toBeFalsy();
});
it('test on optional', () => {
const hook = renderHook(() => useToggle('Hello', 'World'));
callToggle(hook);
expect(hook.result.current[0]).toBe('World');
act(() => {
hook.result.current[1].set('World');
});
expect(hook.result.current[0]).toBe('World');
callToggle(hook);
expect(hook.result.current[0]).toBe('Hello');
});
});
|
543 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useTrackedEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useTrackedEffect/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useTrackedEffect from '../index';
describe('useTrackedEffect', () => {
//We use a array to store which dependency has changed
let changedDepIndexes = [];
let prevDependencies = [];
let currentDependencies = [];
const mockEffectCleanup = jest.fn();
const mockEffectCallback = jest.fn().mockReturnValue(mockEffectCleanup);
const mockEffectWithTracked = jest.fn().mockImplementation((changes, prevDeps, curDeps) => {
//This effect callback accept an addition parameter which contains indexes of dependecies which changed their equalities.
changedDepIndexes = changes;
prevDependencies = prevDeps;
currentDependencies = curDeps;
return mockEffectCleanup;
});
it("should run provided effect and return single changed dependecy's index ", () => {
let var1 = 0;
const var2 = '0';
const var3 = { value: 0 };
const { rerender } = renderHook(() =>
useTrackedEffect(mockEffectWithTracked, [var1, var2, var3]),
);
expect(mockEffectWithTracked).toHaveBeenCalledTimes(1);
rerender();
expect(changedDepIndexes).toHaveLength(3);
changedDepIndexes = [];
var1++;
rerender();
expect(changedDepIndexes).toHaveLength(1);
expect(changedDepIndexes[0]).toBe(0);
});
it('should run provided effect and return correct dependencies (previous and current)', () => {
let var1 = 0;
let var2 = '0';
const var3 = { value: 0 };
const { rerender } = renderHook(() =>
useTrackedEffect(mockEffectWithTracked, [var1, var2, var3]),
);
expect(mockEffectWithTracked).toHaveBeenCalledTimes(1);
rerender();
expect(changedDepIndexes).toHaveLength(3);
changedDepIndexes = [];
var1++;
var2 = '1';
rerender();
expect(prevDependencies[0]).toBe(0);
expect(currentDependencies[0]).toBe(1);
expect(prevDependencies[1] === '0').toBe(true);
expect(currentDependencies[1] === '1').toBe(true);
changedDepIndexes = [];
var2 = '2';
rerender();
expect(prevDependencies[1]).toBe('1');
expect(currentDependencies[1]).toBe('2');
});
it(" should run provided effect and return multiple changed dependecy's indexes", () => {
let var1 = 0;
let var2 = '0';
const var3 = { value: 0 };
const { rerender } = renderHook(() =>
useTrackedEffect(mockEffectWithTracked, [var1, var2, var3]),
);
expect(mockEffectWithTracked).toHaveBeenCalledTimes(1);
rerender();
expect(changedDepIndexes).toHaveLength(3);
changedDepIndexes = [];
var1++;
var2 = '1';
rerender();
expect(changedDepIndexes).toHaveLength(2);
expect(changedDepIndexes[0]).toBe(0);
expect(changedDepIndexes[1]).toBe(1);
changedDepIndexes = [];
var2 = '2';
rerender();
expect(changedDepIndexes).toHaveLength(1);
expect(changedDepIndexes[0]).toBe(1);
});
it('should run provided effect and return empty if no dependency changed', () => {
let var1 = 0;
const var2 = '0';
const var3 = { value: 0 };
const { rerender } = renderHook(() =>
useTrackedEffect(mockEffectWithTracked, [var1, var2, var3]),
);
expect(mockEffectWithTracked).toHaveBeenCalledTimes(1);
rerender();
expect(changedDepIndexes).toHaveLength(3);
changedDepIndexes = [];
var1 = 0;
rerender();
expect(changedDepIndexes).toHaveLength(0);
});
it('should run provided effect and make sure reference equality is correct', () => {
const var1 = 0;
const var2 = '0';
const var3 = { value: 0 };
const { rerender } = renderHook(() =>
useTrackedEffect(mockEffectWithTracked, [var1, var2, var3]),
);
expect(mockEffectWithTracked).toHaveBeenCalledTimes(1);
rerender();
expect(changedDepIndexes).toHaveLength(3);
changedDepIndexes = [];
var3.value = 123;
rerender();
expect(changedDepIndexes).toHaveLength(0);
});
it('should run clean-up provided on unmount as a normal useEffect', () => {
const { unmount } = renderHook(() => useTrackedEffect(mockEffectCallback));
expect(mockEffectCleanup).not.toHaveBeenCalled();
unmount();
expect(mockEffectCleanup).toHaveBeenCalledTimes(1);
});
});
|
548 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useUnmount | petrpan-code/alibaba/hooks/packages/hooks/src/useUnmount/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useUnmount from '../index';
describe('useUnmount', () => {
it('useUnmount should work', async () => {
const fn = jest.fn();
const hook = renderHook(() => useUnmount(fn));
expect(fn).toBeCalledTimes(0);
hook.rerender();
expect(fn).toBeCalledTimes(0);
hook.unmount();
expect(fn).toBeCalledTimes(1);
});
// it('should output error when fn is not a function', () => {
// const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
// renderHook(() => useUnmount(1 as any));
// expect(errSpy).toBeCalledWith('useUnmount expected parameter is a function, got number');
// errSpy.mockRestore();
// });
});
|
553 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useUnmountedRef | petrpan-code/alibaba/hooks/packages/hooks/src/useUnmountedRef/__tests__/index.test.ts | import { renderHook } from '../../utils/tests';
import useUnmountedRef from '../index';
describe('useUnmountedRef', () => {
it('should work', async () => {
const hook = renderHook(() => useUnmountedRef());
expect(hook.result.current.current).toBe(false);
hook.rerender();
expect(hook.result.current.current).toBe(false);
hook.unmount();
expect(hook.result.current.current).toBe(true);
});
});
|
558 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useUpdate | petrpan-code/alibaba/hooks/packages/hooks/src/useUpdate/__tests__/index.test.ts | import { renderHook, act } from '@testing-library/react';
import useUpdate from '..';
import useMemoizedFn from '../../useMemoizedFn';
describe('useUpdate', () => {
it('should update', () => {
let count = 0;
const hooks = renderHook(() => {
const update = useUpdate();
return {
update,
count,
onChange: useMemoizedFn(() => {
count++;
update();
}),
};
});
expect(hooks.result.current.count).toBe(0);
act(hooks.result.current.onChange);
expect(hooks.result.current.count).toBe(1);
});
it('should return same update function', () => {
const hooks = renderHook(() => useUpdate());
const preUpdate = hooks.result.current;
hooks.rerender();
expect(hooks.result.current).toEqual(preUpdate);
});
});
|
563 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useUpdateEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useUpdateEffect/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useUpdateEffect from '../index';
describe('useUpdateEffect', () => {
it('test on mounted', async () => {
let mountedState = 1;
const hook = renderHook(() =>
useUpdateEffect(() => {
mountedState = 2;
}),
);
expect(mountedState).toBe(1);
hook.rerender();
expect(mountedState).toBe(2);
});
it('test on optional', () => {
let mountedState = 1;
const hook = renderHook(() =>
useUpdateEffect(() => {
mountedState = 3;
}, [mountedState]),
);
expect(mountedState).toBe(1);
hook.rerender();
expect(mountedState).toBe(1);
mountedState = 2;
hook.rerender();
expect(mountedState).toBe(3);
});
});
|
568 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useUpdateLayoutEffect | petrpan-code/alibaba/hooks/packages/hooks/src/useUpdateLayoutEffect/__tests__/index.test.ts | import { renderHook } from '@testing-library/react';
import useUpdateLayoutEffect from '../index';
describe('useUpdateLayoutEffect', () => {
it('test on mounted', async () => {
let mountedState = 1;
const hook = renderHook(() =>
useUpdateLayoutEffect(() => {
mountedState = 2;
}),
);
expect(mountedState).toBe(1);
hook.rerender();
expect(mountedState).toBe(2);
});
it('test on optional', () => {
let mountedState = 1;
const hook = renderHook(() =>
useUpdateLayoutEffect(() => {
mountedState = 3;
}, [mountedState]),
);
expect(mountedState).toBe(1);
hook.rerender();
expect(mountedState).toBe(1);
mountedState = 2;
hook.rerender();
expect(mountedState).toBe(3);
});
});
|
573 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useVirtualList | petrpan-code/alibaba/hooks/packages/hooks/src/useVirtualList/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import useVirtualList, { Options } from '../index';
describe('useVirtualList', () => {
describe('virtual list render', () => {
let hook: any;
let container: HTMLDivElement;
let wrapper: HTMLDivElement;
beforeEach(() => {
container = document.createElement('div');
// mock clientheight, clientWidth
// see: https://github.com/testing-library/react-testing-library/issues/353
jest.spyOn(container, 'clientHeight', 'get').mockImplementation(() => 300);
jest.spyOn(container, 'clientWidth', 'get').mockImplementation(() => 300);
wrapper = document.createElement('div');
container.appendChild(wrapper);
document.body.appendChild(container);
});
afterEach(() => {
document.body.removeChild(container);
hook.unmount();
});
const setup = (list: any[] = [], options: {}) => {
hook = renderHook(() => useVirtualList(list as unknown[], options as Options<any>));
};
it('test return list size', () => {
setup(Array.from(Array(99999).keys()), {
containerTarget: () => container,
wrapperTarget: () => wrapper,
itemHeight: 30,
});
act(() => {
hook.result.current[1](80);
});
// 10 items plus 5 overscan * 2
expect(hook.result.current[0].length).toBe(20);
expect(container.scrollTop).toBe(80 * 30);
});
it('test with fixed height', () => {
setup(Array.from(Array(99999).keys()), {
overscan: 0,
itemHeight: 30,
containerTarget: () => container,
wrapperTarget: () => wrapper,
});
act(() => {
hook.result.current[1](20);
});
expect(hook.result.current[0].length).toBe(10);
expect(container.scrollTop).toBe(20 * 30);
});
it('test with dynamic height', async () => {
const list = Array.from(Array(99999).keys());
setup(list, {
overscan: 0,
containerTarget: () => container,
wrapperTarget: () => wrapper,
itemHeight: (i: number, data) => {
expect(list[i] === data).toBe(true);
return i % 2 === 0 ? 30 : 60;
},
});
act(() => {
hook.result.current[1](20);
});
// average height for easy calculation
const averageHeight = (30 + 60) / 2;
expect(hook.result.current[0].length).toBe(Math.floor(300 / averageHeight));
expect(container.scrollTop).toBe(10 * 30 + 10 * 60);
expect((hook.result.current[0][0] as { data: number }).data).toBe(20);
expect((hook.result.current[0][0] as { index: number }).index).toBe(20);
expect((hook.result.current[0][5] as { data: number }).data).toBe(25);
expect((hook.result.current[0][5] as { index: number }).index).toBe(25);
expect(wrapper.style.marginTop).toBe(20 * averageHeight + 'px');
expect(wrapper.style.height).toBe((99998 - 20) * averageHeight + 30 + 'px');
});
});
});
|
579 | 0 | petrpan-code/alibaba/hooks/packages/hooks/src/useWebSocket | petrpan-code/alibaba/hooks/packages/hooks/src/useWebSocket/__tests__/index.test.ts | import { act, renderHook } from '@testing-library/react';
import WS from 'jest-websocket-mock';
import { sleep } from '../../utils/testingHelpers';
import useWebSocket, { ReadyState } from '../index';
const promise: Promise<void> = new Promise((resolve) => resolve());
const wsUrl = 'ws://localhost:9999';
describe('useWebSocket', () => {
afterEach(() => {
WS.clean();
});
it('should work', async () => {
const wsServer = new WS(wsUrl);
const hooks = renderHook(() => useWebSocket(wsUrl));
// connect
expect(hooks.result.current.readyState).toBe(ReadyState.Connecting);
expect(hooks.result.current.latestMessage).toBeUndefined();
await act(async () => {
await wsServer.connected;
return promise;
});
expect(hooks.result.current.readyState).toBe(ReadyState.Open);
// send message
const nowTime = `${Date.now()}`;
hooks.result.current.sendMessage?.(nowTime);
await expect(wsServer).toReceiveMessage(nowTime);
// receive message
act(() => {
wsServer.send(nowTime);
});
expect(hooks.result.current.latestMessage?.data).toBe(nowTime);
// disconnect
act(() => wsServer.close());
await act(async () => {
await wsServer.closed;
return promise;
});
expect(hooks.result.current.readyState).toBe(ReadyState.Closed);
});
it('disconnect should work', async () => {
const wsServer = new WS(wsUrl);
const hooks = renderHook(() => useWebSocket(wsUrl));
// connect
expect(hooks.result.current.readyState).toBe(ReadyState.Connecting);
await act(() => wsServer.connected);
expect(hooks.result.current.readyState).toBe(ReadyState.Open);
// disconnect
act(() => hooks.result.current.disconnect());
await act(() => wsServer.closed);
expect(hooks.result.current.readyState).toBe(ReadyState.Closed);
});
it('useWebSocket should be manually triggered', async () => {
const wsServer = new WS(wsUrl);
// This line is needed for jest-ws-mock to start
new WebSocket(wsUrl);
const hooks = renderHook(() => useWebSocket(wsUrl, { manual: true }));
expect(hooks.result.current.readyState).toBe(ReadyState.Closed);
await act(async () => {
await wsServer.connected;
});
// We set "manual: true", so the connection status should be still closed.
expect(hooks.result.current.readyState).toBe(ReadyState.Closed);
await act(async () => {
hooks.result.current.connect!();
await sleep(100); // To make sure connection is established
});
expect(hooks.result.current.readyState).toBe(ReadyState.Open);
act(() => wsServer.close());
});
it('should not call connect when initial socketUrl is empty', async () => {
const wsServer = new WS(wsUrl);
const onOpen = jest.fn();
const onClose = jest.fn();
let url = '';
const hooks = renderHook(() => useWebSocket(url, { onOpen, onClose }));
await act(async () => {
await sleep(1000);
});
expect(hooks.result.current.readyState).toBe(ReadyState.Closed);
url = wsUrl;
hooks.rerender();
await act(async () => {
await wsServer.connected;
});
expect(hooks.result.current.readyState).toBe(ReadyState.Open);
expect(onOpen).toBeCalledTimes(1);
act(() => wsServer.close());
});
it('change socketUrl should connect correctly', async () => {
const wsUrl1 = 'ws://localhost:8888';
const wsServer1 = new WS(wsUrl);
const wsServer2 = new WS(wsUrl1);
const onOpen = jest.fn();
const onClose = jest.fn();
let url = wsUrl;
const hooks = renderHook(() => useWebSocket(url, { onOpen, onClose, reconnectInterval: 300 }));
expect(hooks.result.current.readyState).toBe(ReadyState.Connecting);
await act(async () => {
await wsServer1.connected;
});
expect(hooks.result.current.readyState).toBe(ReadyState.Open);
url = wsUrl1;
hooks.rerender();
await act(async () => {
await wsServer2.connected;
});
expect(hooks.result.current.readyState).toBe(ReadyState.Open);
await act(async () => {
await sleep(3000);
});
expect(onOpen).toBeCalledTimes(2);
expect(onClose).toBeCalledTimes(1);
act(() => wsServer1.close());
act(() => wsServer2.close());
});
});
|
Subsets and Splits