We could not find what you were looking for.
Please contact the owner of the site that linked you to the original URL and let them know their link is broken.
This is a React page
\nYour Docusaurus site did not load properly.
\nA very common reason is a wrong site baseUrl configuration.
\nCurrent configured baseUrl = '+e+" "+("/"===e?" (default value)":"")+'
\nWe suggest trying baseUrl =
\n\n'}(e)).replace(/0)&&(j.current.unobserve(e),j.current.disconnect(),null!=P&&window.docusaurus.prefetch(P))}))})),j.current.observe(e))},to:P},m&&{isActive:b,activeClassName:y}))}var m=o.forwardRef(h)},4559:function(e,t,n){"use strict";n.d(t,{Z:function(){return u},I:function(){return l}});var r=n(3289);function a(e,t){var n=e.split(/(\{\w+\})/).map((function(e,n){if(n%2==1){var r=null==t?void 0:t[e.slice(1,-1)];if(void 0!==r)return r}return e}));return n.some((function(e){return(0,r.isValidElement)(e)}))?n.map((function(e,t){return(0,r.isValidElement)(e)?r.cloneElement(e,{key:t}):e})).filter((function(e){return""!==e})):n.join("")}var o=n(7529);function i(e){var t,n,r=e.id,a=e.message;if(void 0===r&&void 0===a)throw new Error("Docusaurus translation declarations must have at least a translation id or a default translation message");return null!=(t=null!=(n=o[null!=r?r:a])?n:a)?t:r}function l(e,t){return a(i({message:e.message,id:e.id}),t)}function u(e){var t=e.children,n=e.id,o=e.values;if(t&&"string"!=typeof t)throw console.warn("Illegal.comment can become .namespace--comment) or replace them with your defined ones (like .editor__comment). You can even add new classes.",owner:"dvkndn",noCSS:!0},"file-highlight":{title:"File Highlight",description:"Fetch external files and highlight them with Prism. Used on the Prism website itself.",noCSS:!0},"show-language":{title:"Show Language",description:"Display the highlighted language in code blocks (inline code does not show the label).",owner:"nauzilus",noCSS:!0,require:"toolbar"},"jsonp-highlight":{title:"JSONP Highlight",description:"Fetch content with JSONP and highlight some interesting content (e.g. GitHub/Gists or Bitbucket API).",noCSS:!0,owner:"nauzilus"},"highlight-keywords":{title:"Highlight Keywords",description:"Adds special CSS classes for each keyword for fine-grained highlighting.",owner:"vkbansal",noCSS:!0},"remove-initial-line-feed":{title:"Remove initial line feed",description:"Removes the initial line feed in code blocks.",owner:"Golmote",noCSS:!0},"inline-color":{title:"Inline color",description:"Adds a small inline preview for colors in style sheets.",require:"css-extras",owner:"RunDevelopment"},previewers:{title:"Previewers",description:"Previewers for angles, colors, gradients, easing and time.",require:"css-extras",owner:"Golmote"},autoloader:{title:"Autoloader",description:"Automatically loads the needed languages to highlight the code blocks.",owner:"Golmote",noCSS:!0},"keep-markup":{title:"Keep Markup",description:"Prevents custom markup from being dropped out during highlighting.",owner:"Golmote",optional:"normalize-whitespace",noCSS:!0},"command-line":{title:"Command Line",description:"Display a command line with a prompt and, optionally, the output/response from the commands.",owner:"chriswells0"},"unescaped-markup":{title:"Unescaped Markup",description:"Write markup without having to escape anything."},"normalize-whitespace":{title:"Normalize Whitespace",description:"Supports multiple operations to normalize whitespace in code blocks.",owner:"zeitgeist87",optional:"unescaped-markup",noCSS:!0},"data-uri-highlight":{title:"Data-URI Highlight",description:"Highlights data-URI contents.",owner:"Golmote",noCSS:!0},toolbar:{title:"Toolbar",description:"Attach a toolbar for plugins to easily register buttons on the top of a code block.",owner:"mAAdhaTTah"},"copy-to-clipboard":{title:"Copy to Clipboard Button",description:"Add a button that copies the code block to the clipboard when clicked.",owner:"mAAdhaTTah",require:"toolbar",noCSS:!0},"download-button":{title:"Download Button",description:"A button in the toolbar of a code block adding a convenient way to download a code file.",owner:"Golmote",require:"toolbar",noCSS:!0},"match-braces":{title:"Match braces",description:"Highlights matching braces.",owner:"RunDevelopment"},"diff-highlight":{title:"Diff Highlight",description:"Highlights the code inside diff blocks.",owner:"RunDevelopment",require:"diff"},"filter-highlight-all":{title:"Filter highlightAll",description:"Filters the elements the highlightAll and highlightAllUnder methods actually highlight.",owner:"RunDevelopment",noCSS:!0},treeview:{title:"Treeview",description:"A language with special styles to highlight file system tree structures.",owner:"Golmote"}}})},9910:function(e,t,n){const r=n(5610),a=n(3908),o=new Set;function i(e){void 0===e?e=Object.keys(r.languages).filter((e=>"meta"!=e)):Array.isArray(e)||(e=[e]);const t=[...o,...Object.keys(Prism.languages)];a(r,e,t).load((e=>{if(!(e in r.languages))return void(i.silent||console.warn("Language does not exist: "+e));const t="./prism-"+e;delete n.c[n(557).resolve(t)],delete Prism.languages[e],n(557)(t),o.add(e)}))}i.silent=!1,e.exports=i},557:function(e,t,n){var r={"./":9910};function a(e){var t=o(e);return n(t)}function o(e){if(!n.o(r,e)){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}return r[e]}a.keys=function(){return Object.keys(r)},a.resolve=o,e.exports=a,a.id=557},3908:function(e){"use strict";var t=function(){var e=function(){};function t(e,t){Array.isArray(e)?e.forEach(t):null!=e&&t(e,0)}function n(e){for(var t={},n=0,r=e.length;n“万物之始，大道至简”
本文尝试从简单的单元测试思想着手，探讨如何编写良好的单元测试。以下将主要基于 TypeScript, Jest, React, Enzyme 给出示例。关于单元测试的基本概念和重要性不在本文讨论范围。
编写单元测试的基本方法其实很简单：
而一个好的单元测试的要求也很简单：
一个最简单的例子：
// `add.ts`
function add(a: number, b: number): number {
return a + b;
}
// `add.spec.ts`
test("add(1, 2) should return 3", () => {
expect(add(1, 2)).toBe(3);
});
我们编写单元测试的步骤如下：
1, 2add(...)expect(...).toBe(3)是不是很简单？当然，真实业务场景下我们要测试的单元远比上述例子复杂得多。
这里提到的输入、输出不再是狭义上的函数输入、输出。我们将所有可能影响测试对象行为的外部因素都称之为输入，将所有测试对象运行后对外部造成的影响都称之为输出。这样理解之后，我们就可以化繁为简，将测试过程回归到前面提到的最基本的方法上。
所以编写良好的单元测试首先要做的就是厘清测试对象的输入、输出，掌握覆盖不同形式的输入、断言不同形式的输出的方法。我们将分开讨论它们。
足够简单的输入让我们可以花更少的时间、覆盖更多的场景。输入的来源大致有以下几种：
编写测试覆盖它们的复杂度依次增大。除了第一个，其它都可以看作外部事件，也可以理解为来自外界的副作用。对于普通变量参数，我们只需构造这些参数即可完成给定输入的任务。而对于外部事件，我们要做的就是想办法触发这些事件。
我们依然看一个简单的例子：
// `MyComponent.ts`
window.addEventListener("resize", () => { ... });
如何覆盖？主动发送这个事件：
// `MyComponent.spec.ts`
test("MyComponent", () => {
window.dispatchEvent(new Event("resize"));
// ...
});
再看一个例子：
// `MyComponent.tsx`
const handleChange = (value: string): void => { ... };
return <Editor onChange={handleChange} />
如何覆盖依赖组件的特定事件？主动触发依赖组件的事件：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
wrapper.find(Editor).invoke("onChange")("faked value");
// ...
});
足够简单的输出让我们可以更容易地断言运行结果。输出的形态大致有以下几种：
在测试中对它们进行断言的复杂度依次增大。除了第一个，其它都可以看作对外界的副作用。对于普通变量输出，我们只需简单地断言它的值即可。而对于对外界的副作用，我们要做的就是想办法断言这些副作用的影响。
我们继续看一个简单的例子：
// `handleClick.ts`
function handleClick(): void {
history.push("/next/url");
}
如何断言？我们可以断言副作用的影响结果：
// `handleClick.spec.ts`
test("handleClick", () => {
handleClick();
expect(history.location.pathname).toBe("/next/url");
});
有时副作用所影响的结果难以断言，或者该依赖被 Mocked，那么我们可以监视该副作用的触发点是否被正确调用了：
// `handleClick.spec.ts`
test("handleClick", () => {
const spyOnHistoryPush = jest.spyOn(history, "push");
expect(spyOnHistoryPush).toBeCalledWith("/next/url");
});
再看一个 React 组件的例子：
// `MyComponent.tsx`
const handleValidation = (valid: boolean): void => {
this.setState({ valid });
};
return (
<Form.Item className={this.state.valid ? "valid" : "invalid"}>
<Input />
</Form.Item>
);
如何断言？判断依赖组件的变化：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
// ... after something trigger `handleValidation()`
expect(wrapper.find(Form.Item).prop("className")).toBe("invalid");
});
始终记得要断言测试对象运行后对外界的副作用影响。
另外断言的目标应该是对外的影响，而不是内部状态，因为内部状态并不是测试对象的输出。一个错误的例子：
// `MyComponent.bad.spec.tsx`
expect(wrapper.instance().state.valid).toBe("invalid");
更简单的输入、输出让我们可以更容易地编写好的单元测试，但往往实际情况是业务需求不断增长，组件内部逻辑不断复杂化，输入输出的形式形态更加多样化，为组件编写单元测试的难度也随之陡增。
适时地重构与拆分是解决这个问题的关键。在如今的前端组件化的模式下尤为重要，合理拆分后的组件可以让每个测试单元的输入输出都变得更少、更聚焦。诸如 React, Redux 等主流框架和工具推崇的单向数据流盛行的其中一个原因就是它们巧妙地让各个单元的输入来源、输出影响单一化，从而降低编写单元测试的难度，同时提升组件集成时的信心。
编写良好的单元测试总结下来就是三条：
希望以上内容对大家有所帮助。
]]>blog directory. It supports tags as well!Delete the whole directory if you don't want the blog features. As simple as that!
]]>This is a test post.
A whole bunch of other information.
]]>
Welcome to this blog. This blog is created with Docusaurus 2 alpha.
This is a test post.
A whole bunch of other information.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet
“万物之始，大道至简”
本文尝试从简单的单元测试思想着手，探讨如何编写良好的单元测试。以下将主要基于 TypeScript, Jest, React, Enzyme 给出示例。关于单元测试的基本概念和重要性不在本文讨论范围。
编写单元测试的基本方法其实很简单：
而一个好的单元测试的要求也很简单：
一个最简单的例子：
// `add.ts`
function add(a: number, b: number): number {
return a + b;
}
// `add.spec.ts`
test("add(1, 2) should return 3", () => {
expect(add(1, 2)).toBe(3);
});
我们编写单元测试的步骤如下：
1, 2add(...)expect(...).toBe(3)是不是很简单？当然，真实业务场景下我们要测试的单元远比上述例子复杂得多。
这里提到的输入、输出不再是狭义上的函数输入、输出。我们将所有可能影响测试对象行为的外部因素都称之为输入，将所有测试对象运行后对外部造成的影响都称之为输出。这样理解之后，我们就可以化繁为简，将测试过程回归到前面提到的最基本的方法上。
所以编写良好的单元测试首先要做的就是厘清测试对象的输入、输出，掌握覆盖不同形式的输入、断言不同形式的输出的方法。我们将分开讨论它们。
足够简单的输入让我们可以花更少的时间、覆盖更多的场景。输入的来源大致有以下几种：
编写测试覆盖它们的复杂度依次增大。除了第一个，其它都可以看作外部事件，也可以理解为来自外界的副作用。对于普通变量参数，我们只需构造这些参数即可完成给定输入的任务。而对于外部事件，我们要做的就是想办法触发这些事件。
我们依然看一个简单的例子：
// `MyComponent.ts`
window.addEventListener("resize", () => { ... });
如何覆盖？主动发送这个事件：
// `MyComponent.spec.ts`
test("MyComponent", () => {
window.dispatchEvent(new Event("resize"));
// ...
});
再看一个例子：
// `MyComponent.tsx`
const handleChange = (value: string): void => { ... };
return <Editor onChange={handleChange} />
如何覆盖依赖组件的特定事件？主动触发依赖组件的事件：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
wrapper.find(Editor).invoke("onChange")("faked value");
// ...
});
足够简单的输出让我们可以更容易地断言运行结果。输出的形态大致有以下几种：
在测试中对它们进行断言的复杂度依次增大。除了第一个，其它都可以看作对外界的副作用。对于普通变量输出，我们只需简单地断言它的值即可。而对于对外界的副作用，我们要做的就是想办法断言这些副作用的影响。
我们继续看一个简单的例子：
// `handleClick.ts`
function handleClick(): void {
history.push("/next/url");
}
如何断言？我们可以断言副作用的影响结果：
// `handleClick.spec.ts`
test("handleClick", () => {
handleClick();
expect(history.location.pathname).toBe("/next/url");
});
有时副作用所影响的结果难以断言，或者该依赖被 Mocked，那么我们可以监视该副作用的触发点是否被正确调用了：
// `handleClick.spec.ts`
test("handleClick", () => {
const spyOnHistoryPush = jest.spyOn(history, "push");
expect(spyOnHistoryPush).toBeCalledWith("/next/url");
});
再看一个 React 组件的例子：
// `MyComponent.tsx`
const handleValidation = (valid: boolean): void => {
this.setState({ valid });
};
return (
<Form.Item className={this.state.valid ? "valid" : "invalid"}>
<Input />
</Form.Item>
);
如何断言？判断依赖组件的变化：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
// ... after something trigger `handleValidation()`
expect(wrapper.find(Form.Item).prop("className")).toBe("invalid");
});
始终记得要断言测试对象运行后对外界的副作用影响。
另外断言的目标应该是对外的影响，而不是内部状态，因为内部状态并不是测试对象的输出。一个错误的例子：
// `MyComponent.bad.spec.tsx`
expect(wrapper.instance().state.valid).toBe("invalid");
更简单的输入、输出让我们可以更容易地编写好的单元测试，但往往实际情况是业务需求不断增长，组件内部逻辑不断复杂化，输入输出的形式形态更加多样化，为组件编写单元测试的难度也随之陡增。
适时地重构与拆分是解决这个问题的关键。在如今的前端组件化的模式下尤为重要，合理拆分后的组件可以让每个测试单元的输入输出都变得更少、更聚焦。诸如 React, Redux 等主流框架和工具推崇的单向数据流盛行的其中一个原因就是它们巧妙地让各个单元的输入来源、输出影响单一化，从而降低编写单元测试的难度，同时提升组件集成时的信心。
编写良好的单元测试总结下来就是三条：
希望以上内容对大家有所帮助。
Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
Welcome to this blog. This blog is created with Docusaurus 2 alpha.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet
“万物之始，大道至简”
本文尝试从简单的单元测试思想着手，探讨如何编写良好的单元测试。以下将主要基于 TypeScript, Jest, React, Enzyme 给出示例。关于单元测试的基本概念和重要性不在本文讨论范围。
编写单元测试的基本方法其实很简单：
而一个好的单元测试的要求也很简单：
一个最简单的例子：
// `add.ts`
function add(a: number, b: number): number {
return a + b;
}
// `add.spec.ts`
test("add(1, 2) should return 3", () => {
expect(add(1, 2)).toBe(3);
});
我们编写单元测试的步骤如下：
1, 2add(...)expect(...).toBe(3)是不是很简单？当然，真实业务场景下我们要测试的单元远比上述例子复杂得多。
这里提到的输入、输出不再是狭义上的函数输入、输出。我们将所有可能影响测试对象行为的外部因素都称之为输入，将所有测试对象运行后对外部造成的影响都称之为输出。这样理解之后，我们就可以化繁为简，将测试过程回归到前面提到的最基本的方法上。
所以编写良好的单元测试首先要做的就是厘清测试对象的输入、输出，掌握覆盖不同形式的输入、断言不同形式的输出的方法。我们将分开讨论它们。
足够简单的输入让我们可以花更少的时间、覆盖更多的场景。输入的来源大致有以下几种：
编写测试覆盖它们的复杂度依次增大。除了第一个，其它都可以看作外部事件，也可以理解为来自外界的副作用。对于普通变量参数，我们只需构造这些参数即可完成给定输入的任务。而对于外部事件，我们要做的就是想办法触发这些事件。
我们依然看一个简单的例子：
// `MyComponent.ts`
window.addEventListener("resize", () => { ... });
如何覆盖？主动发送这个事件：
// `MyComponent.spec.ts`
test("MyComponent", () => {
window.dispatchEvent(new Event("resize"));
// ...
});
再看一个例子：
// `MyComponent.tsx`
const handleChange = (value: string): void => { ... };
return <Editor onChange={handleChange} />
如何覆盖依赖组件的特定事件？主动触发依赖组件的事件：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
wrapper.find(Editor).invoke("onChange")("faked value");
// ...
});
足够简单的输出让我们可以更容易地断言运行结果。输出的形态大致有以下几种：
在测试中对它们进行断言的复杂度依次增大。除了第一个，其它都可以看作对外界的副作用。对于普通变量输出，我们只需简单地断言它的值即可。而对于对外界的副作用，我们要做的就是想办法断言这些副作用的影响。
我们继续看一个简单的例子：
// `handleClick.ts`
function handleClick(): void {
history.push("/next/url");
}
如何断言？我们可以断言副作用的影响结果：
// `handleClick.spec.ts`
test("handleClick", () => {
handleClick();
expect(history.location.pathname).toBe("/next/url");
});
有时副作用所影响的结果难以断言，或者该依赖被 Mocked，那么我们可以监视该副作用的触发点是否被正确调用了：
// `handleClick.spec.ts`
test("handleClick", () => {
const spyOnHistoryPush = jest.spyOn(history, "push");
expect(spyOnHistoryPush).toBeCalledWith("/next/url");
});
再看一个 React 组件的例子：
// `MyComponent.tsx`
const handleValidation = (valid: boolean): void => {
this.setState({ valid });
};
return (
<Form.Item className={this.state.valid ? "valid" : "invalid"}>
<Input />
</Form.Item>
);
如何断言？判断依赖组件的变化：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
// ... after something trigger `handleValidation()`
expect(wrapper.find(Form.Item).prop("className")).toBe("invalid");
});
始终记得要断言测试对象运行后对外界的副作用影响。
另外断言的目标应该是对外的影响，而不是内部状态，因为内部状态并不是测试对象的输出。一个错误的例子：
// `MyComponent.bad.spec.tsx`
expect(wrapper.instance().state.valid).toBe("invalid");
更简单的输入、输出让我们可以更容易地编写好的单元测试，但往往实际情况是业务需求不断增长，组件内部逻辑不断复杂化，输入输出的形式形态更加多样化，为组件编写单元测试的难度也随之陡增。
适时地重构与拆分是解决这个问题的关键。在如今的前端组件化的模式下尤为重要，合理拆分后的组件可以让每个测试单元的输入输出都变得更少、更聚焦。诸如 React, Redux 等主流框架和工具推崇的单向数据流盛行的其中一个原因就是它们巧妙地让各个单元的输入来源、输出影响单一化，从而降低编写单元测试的难度，同时提升组件集成时的信心。
编写良好的单元测试总结下来就是三条：
希望以上内容对大家有所帮助。
]]>blog directory. It supports tags as well!Delete the whole directory if you don't want the blog features. As simple as that!
]]>This is a test post.
A whole bunch of other information.
]]>Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
Welcome to this blog. This blog is created with Docusaurus 2 alpha.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet
Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
Welcome to this blog. This blog is created with Docusaurus 2 alpha.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet
Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
“万物之始，大道至简”
本文尝试从简单的单元测试思想着手，探讨如何编写良好的单元测试。以下将主要基于 TypeScript, Jest, React, Enzyme 给出示例。关于单元测试的基本概念和重要性不在本文讨论范围。
编写单元测试的基本方法其实很简单：
而一个好的单元测试的要求也很简单：
一个最简单的例子：
// `add.ts`
function add(a: number, b: number): number {
return a + b;
}
// `add.spec.ts`
test("add(1, 2) should return 3", () => {
expect(add(1, 2)).toBe(3);
});
我们编写单元测试的步骤如下：
1, 2add(...)expect(...).toBe(3)是不是很简单？当然，真实业务场景下我们要测试的单元远比上述例子复杂得多。
这里提到的输入、输出不再是狭义上的函数输入、输出。我们将所有可能影响测试对象行为的外部因素都称之为输入，将所有测试对象运行后对外部造成的影响都称之为输出。这样理解之后，我们就可以化繁为简，将测试过程回归到前面提到的最基本的方法上。
所以编写良好的单元测试首先要做的就是厘清测试对象的输入、输出，掌握覆盖不同形式的输入、断言不同形式的输出的方法。我们将分开讨论它们。
足够简单的输入让我们可以花更少的时间、覆盖更多的场景。输入的来源大致有以下几种：
编写测试覆盖它们的复杂度依次增大。除了第一个，其它都可以看作外部事件，也可以理解为来自外界的副作用。对于普通变量参数，我们只需构造这些参数即可完成给定输入的任务。而对于外部事件，我们要做的就是想办法触发这些事件。
我们依然看一个简单的例子：
// `MyComponent.ts`
window.addEventListener("resize", () => { ... });
如何覆盖？主动发送这个事件：
// `MyComponent.spec.ts`
test("MyComponent", () => {
window.dispatchEvent(new Event("resize"));
// ...
});
再看一个例子：
// `MyComponent.tsx`
const handleChange = (value: string): void => { ... };
return <Editor onChange={handleChange} />
如何覆盖依赖组件的特定事件？主动触发依赖组件的事件：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
wrapper.find(Editor).invoke("onChange")("faked value");
// ...
});
足够简单的输出让我们可以更容易地断言运行结果。输出的形态大致有以下几种：
在测试中对它们进行断言的复杂度依次增大。除了第一个，其它都可以看作对外界的副作用。对于普通变量输出，我们只需简单地断言它的值即可。而对于对外界的副作用，我们要做的就是想办法断言这些副作用的影响。
我们继续看一个简单的例子：
// `handleClick.ts`
function handleClick(): void {
history.push("/next/url");
}
如何断言？我们可以断言副作用的影响结果：
// `handleClick.spec.ts`
test("handleClick", () => {
handleClick();
expect(history.location.pathname).toBe("/next/url");
});
有时副作用所影响的结果难以断言，或者该依赖被 Mocked，那么我们可以监视该副作用的触发点是否被正确调用了：
// `handleClick.spec.ts`
test("handleClick", () => {
const spyOnHistoryPush = jest.spyOn(history, "push");
expect(spyOnHistoryPush).toBeCalledWith("/next/url");
});
再看一个 React 组件的例子：
// `MyComponent.tsx`
const handleValidation = (valid: boolean): void => {
this.setState({ valid });
};
return (
<Form.Item className={this.state.valid ? "valid" : "invalid"}>
<Input />
</Form.Item>
);
如何断言？判断依赖组件的变化：
// `MyComponent.spec.tsx`
test("MyComponent", () => {
const wrapper = shallow(<MyComponent />);
// ... after something trigger `handleValidation()`
expect(wrapper.find(Form.Item).prop("className")).toBe("invalid");
});
始终记得要断言测试对象运行后对外界的副作用影响。
另外断言的目标应该是对外的影响，而不是内部状态，因为内部状态并不是测试对象的输出。一个错误的例子：
// `MyComponent.bad.spec.tsx`
expect(wrapper.instance().state.valid).toBe("invalid");
更简单的输入、输出让我们可以更容易地编写好的单元测试，但往往实际情况是业务需求不断增长，组件内部逻辑不断复杂化，输入输出的形式形态更加多样化，为组件编写单元测试的难度也随之陡增。
适时地重构与拆分是解决这个问题的关键。在如今的前端组件化的模式下尤为重要，合理拆分后的组件可以让每个测试单元的输入输出都变得更少、更聚焦。诸如 React, Redux 等主流框架和工具推崇的单向数据流盛行的其中一个原因就是它们巧妙地让各个单元的输入来源、输出影响单一化，从而降低编写单元测试的难度，同时提升组件集成时的信心。
编写良好的单元测试总结下来就是三条：
希望以上内容对大家有所帮助。
A população portuguesa é composta por 16,4 % com idade compreendida entre os 0 e os 14 anos, 66,2 % entre os 15 e os 64 anos e 17,4 % com mais de 65 anos, como tal, a população tem vindo a envelhecer. A esperança média de vida é de 78,04 anos. Em termos de alfabetização, 93,3 % sabem ler e escrever, tendo a taxa de analfabetismo vindo a descer ao longo dos anos.[82] O crescimento populacional situa-se nos 0,305 %, nascendo 10,45 por cada mil habitantes e falecendo 10,62 por cada mil habitantes, o que faz com que a população esteja a ser renovada, contribuindo para este facto a taxa de fertilidade que se situa nos 1,32 em 2010.[83] Portugal é um dos países com mais baixa taxa de mortalidade infantil abaixo dos 5 anos (3,7 por mil em 2010) no mundo.[84] quilométricas"
This is a link to another document. This is a link to an external page.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. In ac euismod odio, eu consequat dui. Nullam molestie consectetur risus id imperdiet. Proin sodales ornare turpis, non mollis massa ultricies id. Nam at nibh scelerisque, feugiat ante non, dapibus tortor. Vivamus volutpat diam quis tellus elementum bibendum. Praesent semper gravida velit quis aliquam. Etiam in cursus neque. Nam lectus ligula, malesuada et mauris a, bibendum faucibus mi. Phasellus ut interdum felis. Phasellus in odio pulvinar, porttitor urna eget, fringilla lectus. Aliquam sollicitudin est eros. Mauris consectetur quam vitae mauris interdum hendrerit. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Duis et egestas libero, imperdiet faucibus ipsum. Sed posuere eget urna vel feugiat. Vivamus a arcu sagittis, fermentum urna dapibus, congue lectus. Fusce vulputate porttitor nisl, ac cursus elit volutpat vitae. Nullam vitae ipsum egestas, convallis quam non, porta nibh. Morbi gravida erat nec neque bibendum, eu pellentesque velit posuere. Fusce aliquam erat eu massa eleifend tristique.
Sed consequat sollicitudin ipsum eget tempus. Integer a aliquet velit. In justo nibh, pellentesque non suscipit eget, gravida vel lacus. Donec odio ante, malesuada in massa quis, pharetra tristique ligula. Donec eros est, tristique eget finibus quis, semper non nisl. Vivamus et elit nec enim ornare placerat. Sed posuere odio a elit cursus sagittis.
Phasellus feugiat purus eu tortor ultrices finibus. Ut libero nibh, lobortis et libero nec, dapibus posuere eros. Sed sagittis euismod justo at consectetur. Nulla finibus libero placerat, cursus sapien at, eleifend ligula. Vivamus elit nisl, hendrerit ac nibh eu, ultrices tempus dui. Nam tellus neque, commodo non rhoncus eu, gravida in risus. Nullam id iaculis tortor.
Nullam at odio in sem varius tempor sit amet vel lorem. Etiam eu hendrerit nisl. Fusce nibh mauris, vulputate sit amet ex vitae, congue rhoncus nisl. Sed eget tellus purus. Nullam tempus commodo erat ut tristique. Cras accumsan massa sit amet justo consequat eleifend. Integer scelerisque vitae tellus id consectetur.
You can write content using GitHub-flavored Markdown syntax.
To serve as an example page when styling markdown based Docusaurus sites.
Emphasis, aka italics, with asterisks or underscores.
Strong emphasis, aka bold, with asterisks or underscores.
Combined emphasis with asterisks and underscores.
Strikethrough uses two tildes. Scratch this.
I'm an inline-style link with title
You can use numbers for reference-style link definitions
Or leave it empty and use the link text itself.
URLs and URLs in angle brackets will automatically get turned into links. http://www.example.com/ or http://www.example.com/ and sometimes example.com (but not on GitHub, for example).
Some text to show that the reference links can follow later.
Here's our logo (hover to see the title text):
Inline-style: 
Reference-style:
Images from any folder can be used by providing path to file. Path should be relative to markdown file.
var s = "JavaScript syntax highlighting";
alert(s);
s = "Python syntax highlighting"
print(s)
No language indicated, so no syntax highlighting.
But let's throw in a <b>tag</b>.
function highlightMe() {
console.log("This line can be highlighted!");
}
Colons can be used to align columns.
| Tables | Are | Cool |
|---|---|---|
| col 3 is | right-aligned | \$1600 |
| col 2 is | centered | \$12 |
| zebra stripes | are neat | \$1 |
There must be at least 3 dashes separating each header cell. The outer pipes (|) are optional, and you don't need to make the raw Markdown line up prettily. You can also use inline Markdown.
| Markdown | Less | Pretty |
|---|---|---|
| Still | renders | nicely |
| 1 | 2 | 3 |
Blockquotes are very handy in email to emulate reply text. This line is part of the same quote.
Quote break.
This is a very long line that will still be quoted properly when it wraps. Oh boy let's keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can put Markdown into a blockquote.
Here's a line for us to start with.
This line is separated from the one above by two newlines, so it will be a separate paragraph.
This line is also a separate paragraph, but... This line is only separated by a single newline, so it's a separate line in the same paragraph.
This is a note
This is a tip
This is important
This is a caution
This is a warning
You can write JSX and use React components within your Markdown thanks to MDX.
Docusaurus green and Facebook blue are my favorite colors.I can write Markdown alongside my JSX!
5 minutes to learn the most important Docusaurus concepts.
Add Markdown or React files to src/pages to create a standalone page:
Documents are groups of pages connected through:
Docusaurus creates a page for each blog post, but also a blog index page, a tag system, an RSS feed...
Docusaurus supports Markdown and a few additional features.
Docusaurus is a static-site-generator (also called Jamstack).
You have just learned the basics of Docusaurus and made some changes to the initial template.
Let's discover Docusaurus in less than 5 minutes.
Get started by creating a new site.
Or try Docusaurus immediately with docusaurus.new.
Generate a new Docusaurus site using the classic template.
The classic template will automatically be added to your project after you run the command:
npm init docusaurus@latest my-website classic
You can type this command into Command Prompt, Powershell, Terminal, or any other integrated terminal of your code editor.
The command also installs all necessary dependencies you need to run Docusaurus.
Run the development server:
cd my-website
npm run start
The cd command changes the directory you're working with. In order to work with your newly created Docusaurus site, you'll need to navigate the terminal there.
The npm run start command builds your website locally and serves it through a development server, ready for you to view at http://localhost:3000/.
Open docs/intro.md (this page) and edit some lines: the site reloads automatically and displays your changes.
This is a React page
You have just learned the basics of Docusaurus and made some changes to the initial template.
Docusaurus has much more to offer!
Have 5 more minutes? Take a look at versioning and i18n.
Anything unclear or buggy in this tutorial? Please report it!
Docusaurus creates a page for each blog post, but also a blog index page, a tag system, an RSS feed...
Create a file at blog/2021-02-28-greetings.md:
---
slug: greetings
title: Greetings!
authors:
- name: Joel Marcey
title: Co-creator of Docusaurus 1
url: https://github.com/JoelMarcey
image_url: https://github.com/JoelMarcey.png
- name: Sébastien Lorber
title: Docusaurus maintainer
url: https://sebastienlorber.com
image_url: https://github.com/slorber.png
tags: [greetings]
---
Congratulations, you have made your first post!
Feel free to play around and edit this post as much you like.
A new blog post is now available at http://localhost:3000/blog/greetings.
Documents are groups of pages connected through:
Create a markdown file at docs/hello.md:
# Hello
This is my **first Docusaurus document**!
A new document is now available at http://localhost:3000/docs/hello.
Docusaurus automatically creates a sidebar from the docs folder.
Add metadata to customize the sidebar label and position:
---
sidebar_label: 'Hi!'
sidebar_position: 3
---
# Hello
This is my **first Docusaurus document**!
It is also possible to create your sidebar explicitly in sidebars.js:
module.exports = {
tutorialSidebar: [
{
type: 'category',
label: 'Tutorial',
items: ['hello'],
},
],
};
Add Markdown or React files to src/pages to create a standalone page:
src/pages/index.js -> localhost:3000/src/pages/foo.md -> localhost:3000/foosrc/pages/foo/bar.js -> localhost:3000/foo/barCreate a file at src/pages/my-react-page.js:
import React from 'react';
import Layout from '@theme/Layout';
export default function MyReactPage() {
return (
<Layout>
<h1>My React page</h1>
<p>This is a React page</p>
</Layout>
);
}
A new page is now available at http://localhost:3000/my-react-page.
Create a file at src/pages/my-markdown-page.md:
# My Markdown page
This is a Markdown page
A new page is now available at http://localhost:3000/my-markdown-page.
Docusaurus is a static-site-generator (also called Jamstack).
It builds your site as simple static HTML, JavaScript and CSS files.
Build your site for production:
npm run build
The static files are generated in the build folder.
Test your production build locally:
npm run serve
The build folder is now served at http://localhost:3000/.
You can now deploy the build folder almost anywhere easily, for free or very small cost (read the Deployment Guide).
Docusaurus supports Markdown and a few additional features.
Markdown documents have metadata at the top called Front Matter:
---
id: my-doc-id
title: My document title
description: My document description
slug: /my-custom-url
---
## Markdown heading
Markdown text with [links](./hello.md)
Regular Markdown links are supported, using url paths or relative file paths.
Let's see how to [Create a page](/create-a-page).
Let's see how to [Create a page](./create-a-page.md).
Result: Let's see how to Create a page.
Regular Markdown images are supported.
You can use absolute paths to reference images in the static directory (static/img/docusaurus.png):
You can reference images relative to the current file as well, as shown in the extra guides.
Markdown code blocks are supported with Syntax highlighting.
```jsx title="src/components/HelloDocusaurus.js"
function HelloDocusaurus() {
return (
<h1>Hello, Docusaurus!</h1>
)
}
```
function HelloDocusaurus() {
return <h1>Hello, Docusaurus!</h1>;
}
Docusaurus has a special syntax to create admonitions and callouts:
:::tip My tip
Use this awesome feature option
:::
:::danger Take care
This action is dangerous
:::
Use this awesome feature option
This action is dangerous
MDX can make your documentation more interactive and allows using any React components inside Markdown:
export const Highlight = ({children, color}) => (
<span
style={{
backgroundColor: color,
borderRadius: '20px',
color: '#fff',
padding: '10px',
cursor: 'pointer',
}}
onClick={() => {
alert(`You clicked the color ${color} with label ${children}`)
}}>
{children}
</span>
);
This is <Highlight color="#25c2a0">Docusaurus green</Highlight> !
This is Docusaurus green !
This is Facebook blue !
Docusaurus can manage multiple versions of your docs.
Release a version 1.0 of your project:
npm run docusaurus docs:version 1.0
The docs folder is copied into versioned_docs/version-1.0 and versions.json is created.
Your docs now have 2 versions:
1.0 at http://localhost:3000/docs/ for the version 1.0 docscurrent at http://localhost:3000/docs/next/ for the upcoming, unreleased docsTo navigate seamlessly across versions, add a version dropdown.
Modify the docusaurus.config.js file:
module.exports = {
themeConfig: {
navbar: {
items: [
{
type: 'docsVersionDropdown',
},
],
},
},
};
The docs version dropdown appears in your navbar:
It is possible to edit versioned docs in their respective folder:
versioned_docs/version-1.0/hello.md updates http://localhost:3000/docs/hellodocs/hello.md updates http://localhost:3000/docs/next/helloLet's translate docs/intro.md to French.
Modify docusaurus.config.js to add support for the fr locale:
module.exports = {
i18n: {
defaultLocale: 'en',
locales: ['en', 'fr'],
},
};
Copy the docs/intro.md file to the i18n/fr folder:
mkdir -p i18n/fr/docusaurus-plugin-content-docs/current/
cp docs/intro.md i18n/fr/docusaurus-plugin-content-docs/current/intro.md
Translate i18n/fr/docusaurus-plugin-content-docs/current/intro.md in French.
Start your site on the French locale:
npm run start -- --locale fr
Your localized site is accessible at http://localhost:3000/fr/ and the Getting Started page is translated.
In development, you can only use one locale at a same time.
To navigate seamlessly across languages, add a locale dropdown.
Modify the docusaurus.config.js file:
module.exports = {
themeConfig: {
navbar: {
items: [
{
type: 'localeDropdown',
},
],
},
},
};
The locale dropdown now appears in your navbar:
Build your site for a specific locale:
npm run build -- --locale fr
Or build your site to include all the locales at once:
npm run build
An offline/local search example using @easyops-cn/docusaurus-search-local.
A Result You Can Trust.
Dozens of languages supported, including 中文分词 🇨🇳.
Looks pretty good, actually just like the Algolia Search on Docusaurus v2 website.
我们找不到您要找的页面。
请联系原始链接来源网站的所有者，并告知他们链接已损坏。
This is a React page
\n