`
+)
+```
+
+## stubs
+
+- Тип: `{ [name: string]: Component | boolean } | Array`
+
+Заглушки дочерних компонентов. Может быть массивом имен компонентов заменяемых заглушкой, или объектом. Если `stubs` массив, каждая заглушка - `<${component name}-stub>`.
+
+Пример:
+
+```js
+import Foo from './Foo.vue'
+
+mount(Component, {
+ stubs: ['registered-component']
+})
+
+shallowMount(Component, {
+ stubs: {
+ // заглушка со специальной реализацией
+ 'registered-component': Foo,
+ // создание заглушки по умолчанию
+ // в нашем случае имя компонента заглушки
+ // по умолчанию - это another-component
+ // заглушка по умолчанию - <${the component name of default stub}-stub>.
+ 'another-component': true
+ }
+})
+```
+
+## mocks
+
+- Тип: `Object`
+
+Дополнительные свойства для экземпляра. Полезно при создании моков глобальных инъекций.
+
+Пример:
+
+```js
+const $route = { path: 'http://www.example-path.com' }
+const wrapper = shallowMount(Component, {
+ mocks: {
+ $route
+ }
+})
+expect(wrapper.vm.$route.path).toBe($route.path)
+```
+
+## localVue
+
+- Тип: `Vue`
+
+Локальная копия Vue, созданная с помощью [`createLocalVue`](./createLocalVue.md) для использования при монтировании компонента. Установка плагинов на этой копии `Vue` предотвращает загрязнение оригинальной копии `Vue`.
+
+Пример:
+
+```js
+import { createLocalVue, mount } from '@vue/test-utils'
+import VueRouter from 'vue-router'
+import Foo from './Foo.vue'
+
+const localVue = createLocalVue()
+localVue.use(VueRouter)
+
+const routes = [
+ { path: '/foo', component: Foo }
+]
+
+const router = new VueRouter({
+ routes
+})
+
+const wrapper = mount(Component, {
+ localVue,
+ router
+})
+expect(wrapper.vm.$route).toBeInstanceOf(Object)
+```
+
+## attachToDocument
+
+- Тип: `boolean`
+- По умолчанию: `false`
+
+Компонент будет прикрепляться к DOM при рендеринге, если установлено в `true`.
+
+## attrs
+
+- Тип: `Object`
+
+Устанавливает объект `$attrs` на экземпляре компонента.
+
+## listeners
+
+- Тип: `Object`
+
+Устанавливает объект `$listeners` на экземпляре компонента.
+
+## provide
+
+- Тип: `Object`
+
+Передаёт свойства в компоненты для использования в инъекциях. См. [provide/inject](https://ru.vuejs.org/v2/api/#provide-inject).
+
+## sync
+
+- Тип: `boolean`
+- По умолчанию: `true`
+
+Когда `sync` равняется `true`, Vue-компонент рендериться синхронно.
+Когда `sync` равняется `false`, Vue-компонент рендериться асинхронно.
+
+## Другие опции
+
+Если в параметрах для `mount` и `shallowMount` содержатся другие опции, отличные от опций монтирования, опции компонента будут перезаписаны с помощью [extends](https://ru.vuejs.org/v2/api/#extends).
+
+```js
+const Component = {
+ template: '
{{ foo() }}{{ bar() }}{{ baz() }}
',
+ methods: {
+ foo () {
+ return 'a'
+ },
+ bar () {
+ return 'b'
+ }
+ }
+}
+const options = {
+ methods: {
+ bar () {
+ return 'B'
+ },
+ baz () {
+ return 'C'
+ }
+ }
+}
+const wrapper = mount(Component, options)
+expect(wrapper.text()).toBe('aBC')
+```
diff --git a/docs/ru/api/render.md b/docs/ru/api/render.md
new file mode 100644
index 000000000..ebb72f959
--- /dev/null
+++ b/docs/ru/api/render.md
@@ -0,0 +1,103 @@
+## render()
+
+- **Принимает:**
+
+ - `{Component} component`
+ - `{Object} options`
+ - `{Object} context`
+ - `{Array|Component} children`
+ - `{Object} slots`
+ - `{Array|Component|String} default`
+ - `{Array|Component|String} named`
+ - `{Object} mocks`
+ - `{Object|Array} stubs`
+ - `{Vue} localVue`
+
+- **Возвращает:** `{CheerioWrapper}`
+
+- **Опции:**
+
+См. [опции](./options.md)
+
+- **Использование:**
+
+Рендерит объект в строку и возвращает [обёртку cheerio](https://github.com/cheeriojs/cheerio).
+
+Cheerio — библиотека, похожая на jQuery, для навигации по DOM в Node.js. Она имеет аналогичный API в [`Wrapper`](wrapper/) Vue Test Utils.
+
+`render` использует [`vue-server-renderer`](https://ssr.vuejs.org/en/basic.html) под капотом для рендеринга компонента в статический HTML.
+
+`render` включён в пакет `@vue/server-test-utils`.
+
+**Без опций:**
+
+```js
+import { render } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const wrapper = render(Foo)
+ expect(wrapper.text()).toContain('')
+ })
+})
+```
+
+**С опциямиVue:**
+
+```js
+import { render } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const wrapper = render(Foo, {
+ propsData: {
+ color: 'red'
+ }
+ })
+ expect(wrapper.text()).toContain('red')
+ })
+})
+```
+
+**Слоты по умолчанию и именованные слоты:**
+
+```js
+import { render } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+import FooBar from './FooBar.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const wrapper = render(Foo, {
+ slots: {
+ default: [Bar, FooBar],
+ fooBar: FooBar, // Будет соответствовать ,
+ foo: ''
+ }
+ })
+ expect(wrapper.text()).toContain('')
+ })
+})
+```
+
+**Создание заглушек глобальных свойств:**
+
+```js
+import { render } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const $route = { path: 'http://www.example-path.com' }
+ const wrapper = render(Foo, {
+ mocks: {
+ $route
+ }
+ })
+ expect(wrapper.text()).toContain($route.path)
+ })
+})
+```
diff --git a/docs/ru/api/renderToString.md b/docs/ru/api/renderToString.md
new file mode 100644
index 000000000..542e2ed46
--- /dev/null
+++ b/docs/ru/api/renderToString.md
@@ -0,0 +1,101 @@
+## renderToString()
+
+- **Аргументы:**
+
+ - `{Component} component`
+ - `{Object} options`
+ - `{Object} context`
+ - `{Array|Component} children`
+ - `{Object} slots`
+ - `{Array|Component|String} default`
+ - `{Array|Component|String} named`
+ - `{Object} mocks`
+ - `{Object|Array} stubs`
+ - `{Vue} localVue`
+
+- **Возвращает:** `{string}`
+
+- **Опции:**
+
+См. [опции](./options.md)
+
+- **Использование:**
+
+Рендерит компонент в HTML.
+
+`renderToString` использует [`vue-server-renderer`](https://ssr.vuejs.org/en/basic.html) под капотом для рендеринга компонента в статический HTML.
+
+`renderToString` включён в пакет `@vue/server-test-utils`.
+
+**Без опций:**
+
+```js
+import { renderToString } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const renderedString = renderToString(Foo)
+ expect(renderedString).toContain('')
+ })
+})
+```
+
+**С опциями Vue:**
+
+```js
+import { renderToString } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const renderedString = renderToString(Foo, {
+ propsData: {
+ color: 'red'
+ }
+ })
+ expect(renderedString).toContain('red')
+ })
+})
+```
+
+**С слотами по умолчанию и именованными слотами:**
+
+```js
+import { renderToString } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+import FooBar from './FooBar.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const renderedString = renderToString(Foo, {
+ slots: {
+ default: [Bar, FooBar],
+ fooBar: FooBar, // Будет соответствовать ,
+ foo: ''
+ }
+ })
+ expect(renderedString).toContain('')
+ })
+})
+```
+
+**Создание заглушек глобальных свойств:**
+
+```js
+import { renderToString } from '@vue/server-test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('renders a div', () => {
+ const $route = { path: 'http://www.example-path.com' }
+ const renderedString = renderToString(Foo, {
+ mocks: {
+ $route
+ }
+ })
+ expect(renderedString).toContain($route.path)
+ })
+})
+```
diff --git a/docs/ru/api/selectors.md b/docs/ru/api/selectors.md
new file mode 100644
index 000000000..1efc0e93e
--- /dev/null
+++ b/docs/ru/api/selectors.md
@@ -0,0 +1,60 @@
+## Селекторы
+
+Многие методы принимают селектор в качестве аргумента. Селектором может быть CSS селектор, компонент Vue или опция поиска объекта.
+
+### CSS-селекторы
+
+Обрабатывают любой допустимый CSS селектор:
+
+- селекторы тегов (`div`, `foo`, `bar`)
+- селекторы классов (`.foo`, `.bar`)
+- селекторы атрибутов (`[foo]`, `[foo="bar"]`)
+- селекторы id (`#foo`, `#bar`)
+- селекторы псевдо-элементов (`div:first-of-type`)
+
+Вы также можете использовать комбинации:
+
+- выбор только непосредственных потомков (`div > #bar > .foo`)
+- выбор элементов, являющихся потомками (`div #bar .foo`)
+- селектор выбора соседа идущего за элементом (`div + .foo`)
+- селектор выбора соседей идущих после элемента (`div ~ .foo`)
+
+### Компоненты Vue
+
+Компоненты Vue также являются корректными селекторами.
+
+```js
+// Foo.vue
+
+export default {
+ name: 'FooComponent'
+}
+```
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = shallowMount(Foo)
+expect(wrapper.is(Foo)).toBe(true)
+```
+
+### Опция поиска объекта
+
+#### Name
+
+Использование объекта для опции поиска, позволяет Vue Test Utils выбирать элементы по `name` компонента на компонентах обёртках.
+
+```js
+const buttonWrapper = wrapper.find({ name: 'my-button' })
+buttonWrapper.trigger('click')
+```
+
+#### Ref
+
+Использование опции поиска объекта позволяет Vue Test Utils выбирать элементы по `$ref` на компонентах обёрток.
+
+```js
+const buttonWrapper = wrapper.find({ ref: 'myButton' })
+buttonWrapper.trigger('click')
+```
diff --git a/docs/ru/api/shallowMount.md b/docs/ru/api/shallowMount.md
new file mode 100644
index 000000000..389509840
--- /dev/null
+++ b/docs/ru/api/shallowMount.md
@@ -0,0 +1,114 @@
+## shallowMount()
+
+- **Принимает:**
+
+ - `{Component} component`
+ - `{Object} options`
+ - `{boolean} attachToDocument`
+ - `{Object} context`
+ - `{Array|Component} children`
+ - `{Object} slots`
+ - `{Array|Component|String} default`
+ - `{Array|Component|String} named`
+ - `{Object} mocks`
+ - `{Object|Array} stubs`
+ - `{Vue} localVue`
+
+- **Возвращает:** `{Wrapper}`
+
+- **Опции:**
+
+См. [опции монтирования](./options.md)
+
+- **Использование:**
+
+Аналогично [`mount`](mount.md), создаёт [`Wrapper`](wrapper/), который содержит примонтированный и отрендеренный компонент Vue, но с заглушками вместо дочерних компонентов.
+
+**Без опций:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('отрендерить div', () => {
+ const wrapper = shallowMount(Foo)
+ expect(wrapper.contains('div')).toBe(true)
+ })
+})
+```
+
+**С опциями Vue:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('отрендерить div', () => {
+ const wrapper = shallowMount(Foo, {
+ propsData: {
+ color: 'red'
+ }
+ })
+ expect(wrapper.props().color).toBe('red')
+ })
+})
+```
+
+**Прикрепление к DOM:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('отрендерить div', () => {
+ const wrapper = shallowMount(Foo, {
+ attachToDocument: true
+ })
+ expect(wrapper.contains('div')).toBe(true)
+ })
+})
+```
+
+**Слот по умолчанию и именованные слоты:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+import FooBar from './FooBar.vue'
+
+describe('Foo', () => {
+ it('отрендерить div', () => {
+ const wrapper = shallowMount(Foo, {
+ slots: {
+ default: [Bar, FooBar],
+ fooBar: FooBar, // будет соответствовать ,
+ foo: ''
+ }
+ })
+ expect(wrapper.find('div')).toBe(true)
+ })
+})
+```
+
+**Заглушки глобальных свойств:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+describe('Foo', () => {
+ it('отрендерить div', () => {
+ const $route = { path: 'http://www.example-path.com' }
+ const wrapper = shallowMount(Foo, {
+ mocks: {
+ $route
+ }
+ })
+ expect(wrapper.vm.$route.path).toBe($route.path)
+ })
+})
+```
diff --git a/docs/ru/api/wrapper-array/README.md b/docs/ru/api/wrapper-array/README.md
new file mode 100644
index 000000000..12e697934
--- /dev/null
+++ b/docs/ru/api/wrapper-array/README.md
@@ -0,0 +1,27 @@
+# WrapperArray
+
+`WrapperArray` — это объект, содержащий массив [`Wrappers`](../wrapper/) и методы для тестирования `Wrappers`.
+
+## **Свойства**
+
+### `wrappers`
+
+`array` (только для чтения): `array`: массив `Wrappers` содержащихся в `WrapperArray`
+
+### `length`
+
+`number` (только для чтения): `array`: массив `Wrappers` содержащихся в `WrapperArray`
+
+## **Методы**
+
+!!!include(docs/ru/api/wrapper-array/at.md)!!!
+!!!include(docs/ru/api/wrapper-array/contains.md)!!!
+!!!include(docs/ru/api/wrapper-array/destroy.md)!!!
+!!!include(docs/ru/api/wrapper-array/filter.md)!!!
+!!!include(docs/ru/api/wrapper-array/is.md)!!!
+!!!include(docs/ru/api/wrapper-array/isEmpty.md)!!!
+!!!include(docs/ru/api/wrapper-array/isVueInstance.md)!!!
+!!!include(docs/ru/api/wrapper-array/setData.md)!!!
+!!!include(docs/ru/api/wrapper-array/setMethods.md)!!!
+!!!include(docs/ru/api/wrapper-array/setProps.md)!!!
+!!!include(docs/ru/api/wrapper-array/trigger.md)!!!
\ No newline at end of file
diff --git a/docs/ru/api/wrapper-array/at.md b/docs/ru/api/wrapper-array/at.md
new file mode 100644
index 000000000..6ec5883a6
--- /dev/null
+++ b/docs/ru/api/wrapper-array/at.md
@@ -0,0 +1,20 @@
+## at(index)
+
+Возвращает `Wrapper` по указанному индексу `index`. Используется нумерация с нуля (т.е. первый элемент имеет индекс 0).
+
+- **Принимает:**
+ - `{number} index`
+
+- **Возвращает:** `{Wrapper}`
+
+- **Пример:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = shallowMount(Foo)
+const divArray = wrapper.findAll('div')
+const secondDiv = divArray.at(1)
+expect(secondDiv.is('p')).toBe(true)
+```
diff --git a/docs/ru/api/wrapper-array/contains.md b/docs/ru/api/wrapper-array/contains.md
new file mode 100644
index 000000000..b30915d83
--- /dev/null
+++ b/docs/ru/api/wrapper-array/contains.md
@@ -0,0 +1,23 @@
+### contains(selector)
+
+Проверка, что каждая обёртка (`Wrapper`) в `WrapperArray` содержит селектор.
+
+Используйте любой корректный [селектор](../selectors.md).
+
+- **Принимает:**
+ - `{string|Component} selector`
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = shallowMount(Foo)
+const divArray = wrapper.findAll('div')
+expect(divArray.contains('p')).toBe(true)
+expect(divArray.contains(Bar)).toBe(true)
+```
diff --git a/docs/ru/api/wrapper-array/destroy.md b/docs/ru/api/wrapper-array/destroy.md
new file mode 100644
index 000000000..2f1829ebf
--- /dev/null
+++ b/docs/ru/api/wrapper-array/destroy.md
@@ -0,0 +1,16 @@
+## destroy()
+
+Уничтожает каждый `Wrapper` Vue в `WrapperArray`.
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+const divArray = wrapper.findAll('div')
+expect(divArray.contains('p')).toBe(true)
+divArray.destroy()
+expect(divArray.contains('p')).toBe(false)
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper-array/filter.md b/docs/ru/api/wrapper-array/filter.md
new file mode 100644
index 000000000..5b85a4459
--- /dev/null
+++ b/docs/ru/api/wrapper-array/filter.md
@@ -0,0 +1,23 @@
+## filter(predicate)
+
+Фильтр `WrapperArray` с функцией предиката на объектах `Wrapper`.
+
+Поведение этого метода похоже на [Array.prototype.filter](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/filter).
+
+- **Аргументы:**
+ - `{function} predicate`
+
+- **Возвращает:** `{WrapperArray}`
+
+Новый экземпляр `WrapperArray`, содержащий экземпляры `Wrapper`, которые возвращают true для функции предиката.
+
+- **Пример:**
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = shallowMount(Foo)
+const filteredDivArray = wrapper.findAll('div')
+ .filter(w => !w.hasClass('filtered'))
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper-array/is.md b/docs/ru/api/wrapper-array/is.md
new file mode 100644
index 000000000..72c4abf25
--- /dev/null
+++ b/docs/ru/api/wrapper-array/is.md
@@ -0,0 +1,19 @@
+## is(selector)
+
+Проверка, что каждый `Wrapper` в `WrapperArray` DOM-узле или `vm` соответствует [селектору](../selectors.md).
+
+- **Принимает:**
+ - `{string|Component} selector`
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+const divArray = wrapper.find('div')
+expect(divArray.is('div')).toBe(true)
+```
diff --git a/docs/ru/api/wrapper-array/isEmpty.md b/docs/ru/api/wrapper-array/isEmpty.md
new file mode 100644
index 000000000..404390753
--- /dev/null
+++ b/docs/ru/api/wrapper-array/isEmpty.md
@@ -0,0 +1,16 @@
+## isEmpty()
+
+Проверка, что каждый `Wrapper` в `WrapperArray` не содержит дочерних узлов.
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+const divArray = wrapper.findAll('div')
+expect(divArray.isEmpty()).toBe(true)
+```
diff --git a/docs/ru/api/wrapper-array/isVisible.md b/docs/ru/api/wrapper-array/isVisible.md
new file mode 100644
index 000000000..90795af6b
--- /dev/null
+++ b/docs/ru/api/wrapper-array/isVisible.md
@@ -0,0 +1,21 @@
+## isVisible()
+
+Утверждает, что каждый `Wrapper` в `WrapperArray` видимый.
+
+Возвращает `false`, если по крайней мере один элемент предка имеет стиль `display: none` или `visibility: hidden`.
+
+Это можно использовать для утверждения, что компонент скрыт с помощью `v-show`.
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.isVisible()).toBe(true)
+expect(wrapper.findAll('.is-not-visible').isVisible()).toBe(false)
+expect(wrapper.findAll('.is-visible').isVisible()).toBe(true)
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper-array/isVueInstance.md b/docs/ru/api/wrapper-array/isVueInstance.md
new file mode 100644
index 000000000..a28c2a7cb
--- /dev/null
+++ b/docs/ru/api/wrapper-array/isVueInstance.md
@@ -0,0 +1,17 @@
+## isVueInstance()
+
+Проверка, что каждый `Wrapper` в `WrapperArray` является экземпляром Vue.
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = mount(Foo)
+const barArray = wrapper.findAll(Bar)
+expect(barArray.isVueInstance()).toBe(true)
+```
diff --git a/docs/ru/api/wrapper-array/setData.md b/docs/ru/api/wrapper-array/setData.md
new file mode 100644
index 000000000..cb5f2b5f2
--- /dev/null
+++ b/docs/ru/api/wrapper-array/setData.md
@@ -0,0 +1,21 @@
+## setData(data)
+
+Устанавливает данные `Wrapper` `vm` на каждом `Wrapper` в `WrapperArray`.
+
+**Обратите внимание, что каждый `Wrapper` должен содержать экземпляр Vue.**
+
+- **Принимает:**
+ - `{Object} data`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = mount(Foo)
+const barArray = wrapper.findAll(Bar)
+barArray.setData({ foo: 'bar' })
+expect(barArray.at(0).vm.foo).toBe('bar')
+```
diff --git a/docs/ru/api/wrapper-array/setMethods.md b/docs/ru/api/wrapper-array/setMethods.md
new file mode 100644
index 000000000..8bda2fd2b
--- /dev/null
+++ b/docs/ru/api/wrapper-array/setMethods.md
@@ -0,0 +1,25 @@
+## setMethods(methods)
+
+Устанавливает методы `Wrapper` `vm` и выполняет принудительное обновление каждого `Wrapper` в `WrapperArray`.
+
+**Обратите внимание, что каждый `Wrapper` должен содержать экземпляр Vue.**
+
+- **Принимает:**
+ - `{Object} methods`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import sinon from 'sinon'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = mount(Foo)
+const barArray = wrapper.findAll(Bar)
+const clickMethodStub = sinon.stub()
+
+barArray.setMethods({ clickMethod: clickMethodStub })
+barArray.at(0).trigger('click')
+expect(clickMethodStub.called).toBe(true)
+```
diff --git a/docs/ru/api/wrapper-array/setProps.md b/docs/ru/api/wrapper-array/setProps.md
new file mode 100644
index 000000000..d8fcc7092
--- /dev/null
+++ b/docs/ru/api/wrapper-array/setProps.md
@@ -0,0 +1,21 @@
+## setProps(props)
+
+Устанавливает входные параметры `Wrapper` `vm` и выполняет принудительное обновление каждого `Wrapper` в `WrapperArray`.
+
+**Обратите внимание, что каждый `Wrapper` должен содержать экземпляр Vue.**
+
+- **Принимает:**
+ - `{Object} props`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = mount(Foo)
+const barArray = wrapper.findAll(Bar)
+barArray.setProps({ foo: 'bar' })
+expect(barArray.at(0).vm.foo).toBe('bar')
+```
diff --git a/docs/ru/api/wrapper-array/trigger.md b/docs/ru/api/wrapper-array/trigger.md
new file mode 100644
index 000000000..bf505f5e9
--- /dev/null
+++ b/docs/ru/api/wrapper-array/trigger.md
@@ -0,0 +1,26 @@
+## trigger(eventType [, options ])
+
+Генерирует событие на каждом `Wrapper` в `WrapperArray` DOM-узле.
+
+**Обратите внимание, что каждый `Wrapper` должен содержать экземпляр Vue.**
+
+- **Принимает:**
+ - `{string} eventType` **обязательный**
+ - `{Object} options` **опциональный**
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import sinon from 'sinon'
+import Foo from './Foo.vue'
+
+const clickHandler = sinon.stub()
+const wrapper = mount(Foo, {
+ propsData: { clickHandler }
+})
+
+const divArray = wrapper.findAll('div')
+divArray.trigger('click')
+expect(clickHandler.called).toBe(true)
+```
diff --git a/docs/ru/api/wrapper/README.md b/docs/ru/api/wrapper/README.md
new file mode 100644
index 000000000..816eccc4e
--- /dev/null
+++ b/docs/ru/api/wrapper/README.md
@@ -0,0 +1,52 @@
+# Wrapper
+
+Vue Test Utils — это API основанное на использовании обёрток (wrapper).
+
+`Wrapper` — это объект, который содержит примонтированный компонент или VNode и методы для тестирования компонента или VNnode.
+
+## Свойства
+
+### `vm`
+
+`Component` (только для чтения): Это экземпляр `Vue`. Вы можете получить доступ ко всем [методам и свойствам экземпляра](https://ru.vuejs.org/v2/api/index.html#Опции-—-данные) через `wrapper.vm`. Это существует только в обёртке компонента Vue или обёртке компонента Vue, связанной с HTMLElement.
+
+### `element`
+
+`HTMLElement` (только для чтения): Корневой DOM-узел обёртки
+
+### `options`
+
+#### `options.attachedToDocument`
+
+`Boolean` (только для чтения): True, если `attachedToDocument` в опциях монтирования было `true`
+
+#### `options.sync`
+
+`Boolean`: True, если `sync` в опциях монтирования не было `false`
+
+## Методы
+
+!!!include(docs/ru/api/wrapper/attributes.md)!!!
+!!!include(docs/ru/api/wrapper/classes.md)!!!
+!!!include(docs/ru/api/wrapper/contains.md)!!!
+!!!include(docs/ru/api/wrapper/destroy.md)!!!
+!!!include(docs/ru/api/wrapper/emitted.md)!!!
+!!!include(docs/ru/api/wrapper/emittedByOrder.md)!!!
+!!!include(docs/ru/api/wrapper/exists.md)!!!
+!!!include(docs/ru/api/wrapper/find.md)!!!
+!!!include(docs/ru/api/wrapper/findAll.md)!!!
+!!!include(docs/ru/api/wrapper/html.md)!!!
+!!!include(docs/ru/api/wrapper/is.md)!!!
+!!!include(docs/ru/api/wrapper/isEmpty.md)!!!
+!!!include(docs/ru/api/wrapper/isVisible.md)!!!
+!!!include(docs/ru/api/wrapper/isVueInstance.md)!!!
+!!!include(docs/ru/api/wrapper/name.md)!!!
+!!!include(docs/ru/api/wrapper/props.md)!!!
+!!!include(docs/ru/api/wrapper/setChecked.md)!!!
+!!!include(docs/ru/api/wrapper/setData.md)!!!
+!!!include(docs/ru/api/wrapper/setMethods.md)!!!
+!!!include(docs/ru/api/wrapper/setProps.md)!!!
+!!!include(docs/ru/api/wrapper/setSelected.md)!!!
+!!!include(docs/ru/api/wrapper/setValue.md)!!!
+!!!include(docs/ru/api/wrapper/text.md)!!!
+!!!include(docs/ru/api/wrapper/trigger.md)!!!
\ No newline at end of file
diff --git a/docs/ru/api/wrapper/attributes.md b/docs/ru/api/wrapper/attributes.md
new file mode 100644
index 000000000..edbd06933
--- /dev/null
+++ b/docs/ru/api/wrapper/attributes.md
@@ -0,0 +1,15 @@
+## attributes()
+
+Возвращает объект атрибута DOM-узла `Wrapper`.
+
+- **Возвращает:** `{[attribute: string]: any}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.attributes().id).toBe('foo')
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper/classes.md b/docs/ru/api/wrapper/classes.md
new file mode 100644
index 000000000..b97c0292a
--- /dev/null
+++ b/docs/ru/api/wrapper/classes.md
@@ -0,0 +1,17 @@
+## classes()
+
+Возвращает классы DOM-узла `Wrapper`.
+
+Возвращает массив имён классов.
+
+- **Возвращает:** `Array<{string}>`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.classes()).toContain('bar')
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper/contains.md b/docs/ru/api/wrapper/contains.md
new file mode 100644
index 000000000..a0e6dff9b
--- /dev/null
+++ b/docs/ru/api/wrapper/contains.md
@@ -0,0 +1,22 @@
+## contains(selector)
+
+Проверка, что `Wrapper` содержит элемент или компонент, соответствующий [селектору](../selectors.md).
+
+- **Принимает:**
+ - `{string|Component} selector`
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.contains('p')).toBe(true)
+expect(wrapper.contains(Bar)).toBe(true)
+```
+
+- **См. также:** [Селекторы](../selectors.md)
diff --git a/docs/ru/api/wrapper/destroy.md b/docs/ru/api/wrapper/destroy.md
new file mode 100644
index 000000000..b2039ee0e
--- /dev/null
+++ b/docs/ru/api/wrapper/destroy.md
@@ -0,0 +1,19 @@
+## destroy()
+
+Уничтожает экземпляр компонента Vue.
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import sinon from 'sinon'
+
+const spy = sinon.stub()
+mount({
+ render: null,
+ destroyed () {
+ spy()
+ }
+}).destroy()
+expect(spy.calledOnce).toBe(true)
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper/emitted.md b/docs/ru/api/wrapper/emitted.md
new file mode 100644
index 000000000..44e70a4db
--- /dev/null
+++ b/docs/ru/api/wrapper/emitted.md
@@ -0,0 +1,57 @@
+## emitted()
+
+Возвращает объект, содержащий вызванные пользовательские события в `Wrapper` `vm`.
+
+- **Возвращает:** `{ [name: string]: Array> }`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+
+const wrapper = mount(Component)
+
+wrapper.vm.$emit('foo')
+wrapper.vm.$emit('foo', 123)
+
+/*
+wrapper.emitted() возвращает следующий объект:
+{
+ foo: [[], [123]]
+}
+*/
+
+// проверка, что событие было вызвано
+expect(wrapper.emitted().foo).toBeTruthy()
+
+// проверка, что событие вызывалось определённое число раз
+expect(wrapper.emitted().foo.length).toBe(2)
+
+// проверка, что с событием были переданы определённые данные
+expect(wrapper.emitted().foo[1]).toEqual([123])
+```
+
+Вы также можете написать это так:
+
+```js
+// проверка, что событие было вызвано
+expect(wrapper.emitted('foo')).toBeTruthy()
+
+// проверка, что событие вызывалось определённое число раз
+expect(wrapper.emitted('foo').length).toBe(2)
+
+// проверка, что с событием были переданы определённые данные
+expect(wrapper.emitted('foo')[1]).toEqual([123])
+```
+
+Когда метод `.emitted()` вызывается, каждый раз возвращается тот же объект, а не новый, поэтому объект будет обновляться при генерации новых событий:
+
+```js
+const emitted = wrapper.emitted()
+
+expect(emitted.foo.length).toBe(1)
+
+// делаем что-то, что заставляет `wrapper` сгенерировать событие "foo"
+
+expect(emitted.foo.length).toBe(2)
+```
diff --git a/docs/ru/api/wrapper/emittedByOrder.md b/docs/ru/api/wrapper/emittedByOrder.md
new file mode 100644
index 000000000..a084a4578
--- /dev/null
+++ b/docs/ru/api/wrapper/emittedByOrder.md
@@ -0,0 +1,27 @@
+## emittedByOrder()
+
+Возвращает массив, содержащий вызванные пользовательские события в `Wrapper` `vm`.
+
+- **Возвращает:** `Array<{ name: string, args: Array }>`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+
+const wrapper = mount(Component)
+
+wrapper.vm.$emit('foo')
+wrapper.vm.$emit('bar', 123)
+
+/*
+wrapper.emittedByOrder() возвращает следующий массив:
+[
+ { name: 'foo', args: [] },
+ { name: 'bar', args: [123] }
+]
+*/
+
+// проверка, что события были вызваны в определённом порядке
+expect(wrapper.emittedByOrder().map(e => e.name)).toEqual(['foo', 'bar'])
+```
diff --git a/docs/ru/api/wrapper/exists.md b/docs/ru/api/wrapper/exists.md
new file mode 100644
index 000000000..48802b867
--- /dev/null
+++ b/docs/ru/api/wrapper/exists.md
@@ -0,0 +1,20 @@
+## exists()
+
+Проверка, что `Wrapper` или `WrapperArray` существует.
+
+Возвращает `false`, если вызывается на пустом `Wrapper` или `WrapperArray`.
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.exists()).toBe(true)
+expect(wrapper.find('does-not-exist').exists()).toBe(false)
+expect(wrapper.findAll('div').exists()).toBe(true)
+expect(wrapper.findAll('does-not-exist').exists()).toBe(false)
+```
diff --git a/docs/ru/api/wrapper/find.md b/docs/ru/api/wrapper/find.md
new file mode 100644
index 000000000..422d6e6e0
--- /dev/null
+++ b/docs/ru/api/wrapper/find.md
@@ -0,0 +1,32 @@
+## find(selector)
+
+Возвращает `Wrapper` первого DOM-узла или компонента Vue, соответствующего селектору.
+
+Используйте любой корректный [селектор](../selectors.md).
+
+- **Принимает:**
+ - `{string|Component} selector`
+
+- **Возвращает:** `{Wrapper}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = mount(Foo)
+
+const div = wrapper.find('div')
+expect(div.is('div')).toBe(true)
+
+const bar = wrapper.find(Bar)
+expect(bar.is(Bar)).toBe(true)
+
+const barByName = wrapper.find({ name: 'bar' })
+expect(barByName.is(Bar)).toBe(true)
+
+const fooRef = wrapper.find({ ref: 'foo' })
+expect(fooRef.is(Foo)).toBe(true)
+```
diff --git a/docs/ru/api/wrapper/findAll.md b/docs/ru/api/wrapper/findAll.md
new file mode 100644
index 000000000..7fc9c4f55
--- /dev/null
+++ b/docs/ru/api/wrapper/findAll.md
@@ -0,0 +1,24 @@
+## findAll(selector)
+
+Возвращает [`WrapperArray`](../wrapper-array/).
+
+Используйте любой корректный [селектор](../selectors.md).
+
+- **Принимает:**
+ - `{string|Component} selector`
+
+- **Возвращает:** `{WrapperArray}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+import Bar from './Bar.vue'
+
+const wrapper = mount(Foo)
+const div = wrapper.findAll('div').at(0)
+expect(div.is('div')).toBe(true)
+const bar = wrapper.findAll(Bar).at(0)
+expect(bar.is(Bar)).toBe(true)
+```
diff --git a/docs/ru/api/wrapper/html.md b/docs/ru/api/wrapper/html.md
new file mode 100644
index 000000000..eb0d42a54
--- /dev/null
+++ b/docs/ru/api/wrapper/html.md
@@ -0,0 +1,15 @@
+## html()
+
+Возвращает HTML `Wrapper` DOM-узла в виде строки.
+
+- **Возвращает:** `{string}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.html()).toBe('
Foo
')
+```
diff --git a/docs/ru/api/wrapper/is.md b/docs/ru/api/wrapper/is.md
new file mode 100644
index 000000000..ace3b5d38
--- /dev/null
+++ b/docs/ru/api/wrapper/is.md
@@ -0,0 +1,18 @@
+## is(selector)
+
+Проверяет, что DOM-элемент `Wrapper` или `vm` соответствуют [селектору](../selectors.md).
+
+- **Принимает:**
+ - `{string|Component} selector`
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.is('div')).toBe(true)
+```
diff --git a/docs/ru/api/wrapper/isEmpty.md b/docs/ru/api/wrapper/isEmpty.md
new file mode 100644
index 000000000..c644c007e
--- /dev/null
+++ b/docs/ru/api/wrapper/isEmpty.md
@@ -0,0 +1,15 @@
+## isEmpty()
+
+Проверяет, что `Wrapper` не содержит дочерних узлов.
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.isEmpty()).toBe(true)
+```
diff --git a/docs/ru/api/wrapper/isVisible.md b/docs/ru/api/wrapper/isVisible.md
new file mode 100644
index 000000000..0d7559649
--- /dev/null
+++ b/docs/ru/api/wrapper/isVisible.md
@@ -0,0 +1,20 @@
+## isVisible()
+
+Утверждает, что `Wrapper` видимый.
+
+Возвращает `false`, если по крайней мере один элемент предка имеет стиль `display: none` или `visibility: hidden`.
+
+Это можно использовать для утверждения, что компонент скрыт с помощью `v-show`.
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.isVisible()).toBe(true)
+expect(wrapper.find('.is-not-visible').isVisible()).toBe(false)
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper/isVueInstance.md b/docs/ru/api/wrapper/isVueInstance.md
new file mode 100644
index 000000000..1f3805957
--- /dev/null
+++ b/docs/ru/api/wrapper/isVueInstance.md
@@ -0,0 +1,15 @@
+## isVueInstance()
+
+Проверка, что `Wrapper` является экземпляром Vue.
+
+- **Возвращает:** `{boolean}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.isVueInstance()).toBe(true)
+```
diff --git a/docs/ru/api/wrapper/name.md b/docs/ru/api/wrapper/name.md
new file mode 100644
index 000000000..7c51791e3
--- /dev/null
+++ b/docs/ru/api/wrapper/name.md
@@ -0,0 +1,17 @@
+## name()
+
+Возвращает имя компонента, если `Wrapper` содержит экземпляр Vue, или имя тега DOM-узла `Wrapper`, если `Wrapper` не содержит экземпляр Vue.
+
+- **Возвращает:** `{string}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.name()).toBe('Foo')
+const p = wrapper.find('p')
+expect(p.name()).toBe('p')
+```
diff --git a/docs/ru/api/wrapper/props.md b/docs/ru/api/wrapper/props.md
new file mode 100644
index 000000000..7b6b132dd
--- /dev/null
+++ b/docs/ru/api/wrapper/props.md
@@ -0,0 +1,21 @@
+## props()
+
+Возвращает объект с входными параметрами `vm` для `Wrapper`.
+
+**Обратите внимание что Wrapper должен содержать экземпляр Vue.**
+
+- **Возвращает:** `{[prop: string]: any}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo, {
+ propsData: {
+ bar: 'baz'
+ }
+})
+expect(wrapper.props().bar).toBe('baz')
+```
\ No newline at end of file
diff --git a/docs/ru/api/wrapper/setChecked.md b/docs/ru/api/wrapper/setChecked.md
new file mode 100644
index 000000000..d080a6b77
--- /dev/null
+++ b/docs/ru/api/wrapper/setChecked.md
@@ -0,0 +1,29 @@
+## setChecked(checked)
+
+Устанавливает значение отмеченным элемент ввода типа чекбокса или радиокнопки и обновляет связанные данные с `v-model`.
+
+- **Аргументы:**
+ - `{Boolean} checked (default: true)`
+
+- **Примеры:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+const option = wrapper.find('input[type="radio"]')
+option.setChecked()
+```
+
+- **Примечание:**
+
+Когда вы пытаетесь установить значение в состояние через `v-model` с помощью `radioInput.element.checked = true; radioInput.trigger('input')`, `v-model` не вызывается. `v-model` генерируется событием `change`.
+
+`checkboxInput.setChecked(checked)` — псевдоним для следующего кода.
+
+```js
+checkboxInput.element.checked = checked
+checkboxInput.trigger('click')
+checkboxInput.trigger('change')
+```
diff --git a/docs/ru/api/wrapper/setData.md b/docs/ru/api/wrapper/setData.md
new file mode 100644
index 000000000..f672fb89e
--- /dev/null
+++ b/docs/ru/api/wrapper/setData.md
@@ -0,0 +1,21 @@
+## setData(data)
+
+Устанавливает данные `Wrapper` `vm`.
+
+**Обратите внимание, что `Wrapper` должен содержать экземпляр Vue.**
+
+setData работает путём слияния существующих свойств, за исключением массивов, которые перезаписываются.
+
+- **Принимает:**
+ - `{Object} data`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+wrapper.setData({ foo: 'bar' })
+expect(wrapper.vm.foo).toBe('bar')
+```
diff --git a/docs/ru/api/wrapper/setMethods.md b/docs/ru/api/wrapper/setMethods.md
new file mode 100644
index 000000000..19316d29a
--- /dev/null
+++ b/docs/ru/api/wrapper/setMethods.md
@@ -0,0 +1,23 @@
+## setMethods(methods)
+
+Устанавливает методы `Wrapper` `vm` и выполняет принудительное обновление.
+
+**Обратите внимание, что `Wrapper` должен содержать экземпляр Vue.**
+
+- **Принимает:**
+ - `{Object} methods`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import sinon from 'sinon'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+const clickMethodStub = sinon.stub()
+
+wrapper.setMethods({ clickMethod: clickMethodStub })
+wrapper.find('button').trigger('click')
+expect(clickMethodStub.called).toBe(true)
+```
diff --git a/docs/ru/api/wrapper/setProps.md b/docs/ru/api/wrapper/setProps.md
new file mode 100644
index 000000000..06e83e345
--- /dev/null
+++ b/docs/ru/api/wrapper/setProps.md
@@ -0,0 +1,46 @@
+## setProps(props)
+
+- **Принимает:**
+ - `{Object} props`
+
+- **Использование:**
+
+Устанавливает входные параметры `Wrapper` `vm` и выполняет принудительное обновление.
+
+**Обратите внимание, что `Wrapper` должен содержать экземпляр Vue.**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+wrapper.setProps({ foo: 'bar' })
+expect(wrapper.vm.foo).toBe('bar')
+```
+
+Вы также можете передать объект `propsData`, который инициализирует экземпляр Vue с переданными значениями.
+
+``` js
+// Foo.vue
+export default {
+ props: {
+ foo: {
+ type: String,
+ required: true
+ }
+ }
+}
+```
+
+``` js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo, {
+ propsData: {
+ foo: 'bar'
+ }
+})
+
+expect(wrapper.vm.foo).toBe('bar')
+```
diff --git a/docs/ru/api/wrapper/setSelected.md b/docs/ru/api/wrapper/setSelected.md
new file mode 100644
index 000000000..623d5054b
--- /dev/null
+++ b/docs/ru/api/wrapper/setSelected.md
@@ -0,0 +1,26 @@
+## setSelected()
+
+Выбирает элемент пункта списка и обновляет связанные данные `v-model`.
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = shallowMount(Foo)
+const options = wrapper.find('select').findAll('option')
+
+options.at(1).setSelected()
+```
+
+- **Примечание:**
+
+Когда вы пытаетесь установить значение в состояние через `v-model` с помощью `option.element.selected = true; parentSelect.trigger('input')`, `v-model` не вызывается. `v-model` генерируется событием `change`.
+
+`option.setSelected()` — псевдоним для следующего кода.
+
+```js
+option.element.selected = true
+parentSelect.trigger('change')
+```
diff --git a/docs/ru/api/wrapper/setValue.md b/docs/ru/api/wrapper/setValue.md
new file mode 100644
index 000000000..6d27c83da
--- /dev/null
+++ b/docs/ru/api/wrapper/setValue.md
@@ -0,0 +1,26 @@
+## setValue(value)
+
+Устанавливает значение ввода текстового элемента и обновляет связанные данные `v-model`.
+
+- **Аргументы:**
+ - `{String} value`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+const input = wrapper.find('input[type="text"]')
+input.setValue('some value')
+```
+
+- **Примечание:**
+
+`textInput.setValue(value)` — псевдоним следующего кода.
+
+```js
+textInput.element.value = value
+textInput.trigger('input')
+```
diff --git a/docs/ru/api/wrapper/text.md b/docs/ru/api/wrapper/text.md
new file mode 100644
index 000000000..aeaeaa71d
--- /dev/null
+++ b/docs/ru/api/wrapper/text.md
@@ -0,0 +1,15 @@
+## text()
+
+Возвращает текстовое содержимое `Wrapper`.
+
+- **Возвращает:** `{string}`
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import Foo from './Foo.vue'
+
+const wrapper = mount(Foo)
+expect(wrapper.text()).toBe('bar')
+```
diff --git a/docs/ru/api/wrapper/trigger.md b/docs/ru/api/wrapper/trigger.md
new file mode 100644
index 000000000..9bf296559
--- /dev/null
+++ b/docs/ru/api/wrapper/trigger.md
@@ -0,0 +1,44 @@
+## trigger(eventType [, options ])
+
+Вызывает событие на `Wrapper` DOM-узле.
+
+В `trigger` также можно передать опциональный объект `options`. Свойства объекта `options` будут добавлены к Event.
+
+- **Принимает:**
+ - `{string} eventName` **обязательный**
+ - `{Object} options` **опциональный**
+
+- **Пример:**
+
+```js
+import { mount } from '@vue/test-utils'
+import sinon from 'sinon'
+import Foo from './Foo'
+
+const clickHandler = sinon.stub()
+const wrapper = mount(Foo, {
+ propsData: { clickHandler }
+})
+
+wrapper.trigger('click')
+
+wrapper.trigger('click', {
+ button: 0
+})
+
+expect(clickHandler.called).toBe(true)
+```
+
+- **Установка target для event:**
+
+Под капотом `trigger` создаёт объект `Event` и вызывает событие на элементе Wrapper.
+
+Невозможно изменить значение `target` объекта `Event`, поэтому вы не можете установить `target` в объекте опций.
+
+Чтобы добавить атрибут к `target`, вам нужно установить значение элемента Wrapper перед вызовом `trigger`. Вы можете сделать это с помощью свойства `element`.
+
+```js
+const input = wrapper.find('input')
+input.element.value = 100
+input.trigger('click')
+```
\ No newline at end of file
diff --git a/docs/ru/guides/README.md b/docs/ru/guides/README.md
new file mode 100644
index 000000000..80b816aec
--- /dev/null
+++ b/docs/ru/guides/README.md
@@ -0,0 +1,12 @@
+# Руководства
+
+!!!include(docs/ru/guides/getting-started.md)!!!
+!!!include(docs/ru/guides/common-tips.md)!!!
+!!!include(docs/ru/guides/dom-events.md)!!!
+!!!include(docs/ru/guides/choosing-a-test-runner.md)!!!
+!!!include(docs/ru/guides/testing-SFCs-with-jest.md)!!!
+!!!include(docs/ru/guides/testing-SFCs-with-mocha-webpack.md)!!!
+!!!include(docs/ru/guides/testing-SFCs-with-karma.md)!!!
+!!!include(docs/ru/guides/testing-async-components.md)!!!
+!!!include(docs/ru/guides/using-with-vue-router.md)!!!
+!!!include(docs/ru/guides/using-with-vuex.md)!!!
\ No newline at end of file
diff --git a/docs/ru/guides/choosing-a-test-runner.md b/docs/ru/guides/choosing-a-test-runner.md
new file mode 100644
index 000000000..31ee85bc3
--- /dev/null
+++ b/docs/ru/guides/choosing-a-test-runner.md
@@ -0,0 +1,46 @@
+## Чем запускать тесты
+
+Test runner — это программа, которая запускает тесты.
+
+Есть много популярных программ запуска тестов для JavaScript, и `vue-test-utils` работает с любой из них. Нет зависимости от используемого test runner.
+
+Есть несколько вещей, которые следует учитывать при выборе программы запуска тестов: набор функций, производительность и поддержка предварительной компиляции однофайловых компонентов. После тщательного сравнения существующих библиотек мы рекомендуем два варианта конфигурации:
+
+- [Jest](https://facebook.github.io/jest/docs/en/getting-started.html#content) наиболее функциональный способ запуска тестов. Он меньше всех требует конфигурирования, устанавливает JSDOM по умолчанию, предоставляет встроенные проверки (assertions) и имеет отличный интерфейс для работы через командную строку. Тем не менее, вам понадобится пре-процессор, чтобы иметь возможность импортировать однофайловые компоненты в свои тесты. Мы создали пре-процессор `vue-jest`, который может обрабатывать наиболее распространённые функции однофайловых компонентов, но в настоящее время он не имеет 100% паритетности функций с `vue-loader`.
+
+- [mocha-webpack](https://github.com/zinserjan/mocha-webpack) — это обёртка вокруг webpack + Mocha, но с более оптимизированным интерфейсом и режимом отслеживания. Преимущества этой конфигурации в том, что мы можем получить полную поддержку однофайловых компонентов с помощью webpack + `vue-loader`, но для этого требуется больше настройки.
+
+### Браузерное окружение
+
+`vue-test-utils` полагается на браузерное окружение. Технически вы можете запустить его в реальном браузере, но это не рекомендуется из-за сложности запуска реальных браузеров на разных платформах. Вместо этого мы рекомендуем запускать тесты в Node с виртуальным браузерным окружением, реализуемым с помощью [JSDOM](https://github.com/tmpvar/jsdom).
+
+Jest настраивает JSDOM автоматически. Для других программ запуска тестов вы можете вручную настроить JSDOM для тестов с помощью [jsdom-global](https://github.com/rstacruz/jsdom-global) в записи для ваших тестов:
+
+``` bash
+npm install --save-dev jsdom jsdom-global
+```
+---
+``` js
+// в настройке теста / entry
+require('jsdom-global')()
+```
+
+### Тестирование однофайловых компонентов
+
+Однофайловые компоненты Vue требуют предварительной компиляции, прежде чем могут быть запущены в Node или в браузере. Существует два рекомендуемых способа выполнения компиляции: с пре-процессором Jest, или непосредственно с помощью webpack.
+
+Пре-процессор `vue-jest` поддерживает базовую функциональность однофайловых компонентов, но в настоящее время не обрабатывает блоки стилей или пользовательские блоки, которые поддерживаются только в `vue-loader`. Если вы полагаетесь на эти функции или другие конфигурации, специфичные для webpack, вам нужно будет использовать связку webpack + `vue-loader`.
+
+Изучите следующие руководства по вариантам настройки:
+
+- [Тестирование однофайловых компонентов с Jest](./testing-SFCs-with-jest.md)
+- [Тестирование однофайловых компонентов с Mocha + webpack](./testing-SFCs-with-mocha-webpack.md)
+
+### Дополнительные ресурсы
+
+- [Сравнение производительности программ для запуска тестов](https://github.com/eddyerburgh/vue-unit-test-perf-comparison)
+- [Пример проекта с Jest](https://github.com/vuejs/vue-test-utils-jest-example)
+- [Пример проекта с Mocha](https://github.com/vuejs/vue-test-utils-mocha-webpack-example)
+- [Пример проекта с tape](https://github.com/eddyerburgh/vue-test-utils-tape-example)
+- [Пример проекта с AVA](https://github.com/eddyerburgh/vue-test-utils-ava-example)
+- [tyu — Восхитительное веб-тестирование от egoist](https://github.com/egoist/tyu)
\ No newline at end of file
diff --git a/docs/ru/guides/common-tips.md b/docs/ru/guides/common-tips.md
new file mode 100644
index 000000000..a0056d95a
--- /dev/null
+++ b/docs/ru/guides/common-tips.md
@@ -0,0 +1,141 @@
+## Общие советы
+
+### Понимание что тестировать
+
+Для компонентов пользовательского интерфейса мы не рекомендуем стремиться к покрытию каждой строки кода, поскольку это приводит к слишком большому фокусу на деталях внутренней реализации компонентов и может привести к созданию хрупких тестов.
+
+Вместо этого, мы рекомендуем писать тесты, которые проверяют ваш публичный интерфейс взаимодействия с компонентом и относиться к его внутренностям как к чёрному ящику. Один тестовый пример должен проверять, что некоторые входные данные (взаимодействие пользователя или изменение входных параметров), предоставляемые компоненту будут приводить к ожидаемому результату (результату рендеринга или вызванным пользовательским событиям).
+
+Например, для компонента `Counter`, который при каждом нажатии кнопки будет увеличивать отображаемый счётчик на 1, может тестироваться с помощью симуляции клика и проверке, что в отрендренном результате значение будет увеличено на 1. Тест не заботится о том, каким образом `Counter` увеличивает значение, он сосредоточен только на входных данных и результате.
+
+Преимуществом этого подхода в том, что до тех пор пока интерфейс вашего компонента остаётся прежним, ваши тесты будут проходить независимо от того, как будет меняться внутренняя реализация компонента с течением времени.
+
+Эта тема обсуждается более подробно в [отличной презентации Matt O'Connell](https://www.youtube.com/watch?v=OIpfWTThrK8).
+
+### Поверхностный рендеринг
+
+В модульных тестах мы обычно хотим сосредоточиться на тестируемом компоненте, как на изолированном блоке и избежать неявной проверки поведения его дочерних компонентов.
+
+Кроме того, для компонентов, которые содержат много дочерних компонентов, отрендеренное дерево целиком может стать очень большим. Повторяющийся рендеринг всех дочерних компонентов может замедлить наши тесты.
+
+`vue-test-utils` позволяет вам монтировать компонент без рендеринга его дочерних компонентов (заменяя их заглушками) с помощью метода `shallowMount`:
+
+```js
+import { shallowMount } from '@vue/test-utils'
+
+const wrapper = shallowMount(Component)
+wrapper.vm // примонтированный экземпляр Vue
+```
+
+### Проверка вызванных событий
+
+Каждая примонтированная обёртка автоматически записывает все события, вызванные на экземпляре Vue. Вы можете получить записанные события с помощью метода `wrapper.emitted()`:
+
+``` js
+wrapper.vm.$emit('foo')
+wrapper.vm.$emit('foo', 123)
+
+/*
+`wrapper.emitted()` возвращает указанный объект:
+{
+ foo: [[], [123]]
+}
+*/
+```
+
+Затем вы можете добавить проверки на основе этих данных:
+
+``` js
+// проверка, что событие было вызвано
+expect(wrapper.emitted().foo).toBeTruthy()
+
+// проверка, что событие вызывалось определённое число раз
+expect(wrapper.emitted().foo.length).toBe(2)
+
+// проверка, что с событием были переданы определённые данные
+expect(wrapper.emitted().foo[1]).toEqual([123])
+```
+
+Вы также можете получить массив событий в порядке их вызова с помощью [`wrapper.emittedByOrder()`](../api/wrapper/emittedByOrder.md).
+
+### Манипулирование состоянием компонента
+
+Вы можете напрямую манипулировать состоянием компонента с помощью методов `setData` или `setProps` на обёртке:
+
+```js
+wrapper.setData({ count: 10 })
+
+wrapper.setProps({ foo: 'bar' })
+```
+
+### Моки входных параметров
+
+Вы можете передать входные параметры в компонент с использованием встроенной во Vue опции `propsData`:
+
+```js
+import { mount } from '@vue/test-utils'
+
+mount(Component, {
+ propsData: {
+ aProp: 'some value'
+ }
+})
+```
+
+Вы также можете обновить входные параметры на уже примонтированном компоненте с помощью метода `wrapper.setProps({})`.
+
+*Полный список опции можно посмотреть в [секции настроек монтирования](../api/options.md) документации.*
+
+### Добавление глобальных плагинов и примесей
+
+Некоторые из компонентов могут полагаться на функции, добавляемые глобальным плагином или примесью, к примеру `vuex` и `vue-router`.
+
+Если вы пишете тесты для компонентов определённого приложения, вы можете настроить одни и те же глобальные плагины и примеси один раз перед началом ваших тестов. Но в некоторых случаях, например при тестировании набора общих компонентов, которые могут использоваться в разных приложениях, гораздо лучше протестировать ваши компоненты в более изолированной конфигурации, без загрязнения глобального конструктора `Vue`. Мы можем использовать метод [`createLocalVue`](../api/createLocalVue.md) для достижения этого:
+
+``` js
+import { createLocalVue } from '@vue/test-utils'
+
+// создаём расширенный конструктор `Vue`
+const localVue = createLocalVue()
+
+// устанавливаем плагины как обычно
+localVue.use(MyPlugin)
+
+// передаём `localVue` в настройки монтирования
+mount(Component, {
+ localVue
+})
+```
+
+**Обратите внимание, что некоторые плагины, такие как Vue Router, добавляют свойства только для чтения к глобальному конструктору Vue. Это делает невозможным переустановку плагина на конструкторе localVue или добавление моков для этих свойств**
+
+### Создание моков инъекций
+
+Другая стратегия для инъекции входных параметров — просто создание их моков. Вы можете это сделать с помощью опции `mocks`:
+
+```js
+import { mount } from '@vue/test-utils'
+
+const $route = {
+ path: '/',
+ hash: '',
+ params: { id: '123' },
+ query: { q: 'hello' }
+}
+
+mount(Component, {
+ mocks: {
+ // добавление мока объекта `$route` в экземпляр Vue
+ // перед монтированием компонента
+ $route
+ }
+})
+```
+
+### Работа с маршрутизацией
+
+Поскольку маршрутизация по определению имеет отношение к общей структуре приложения и включает в себя несколько компонентов, её лучше всего тестировать с помощью интеграционных или end-to-end тестов. Для отдельных компонентов, которые используют возможности `vue-router`, вы можете создать моки с использованием упомянутых выше методов.
+
+### Обнаружение стилей
+
+Ваш тест может обнаруживать только встроенные стили при в `jsdom`.
diff --git a/docs/ru/guides/dom-events.md b/docs/ru/guides/dom-events.md
new file mode 100644
index 000000000..92338d305
--- /dev/null
+++ b/docs/ru/guides/dom-events.md
@@ -0,0 +1,212 @@
+## Тестирование нажатий клавиш, мыши и других событий DOM
+
+### Генерация событий
+
+`Wrapper` предоставляет метод `trigger`. Его можно использовать для генерации событий DOM.
+
+```js
+const wrapper = mount(MyButton)
+
+wrapper.trigger('click')
+```
+
+Вы должны помнить, что метод `find` также возвращает `Wrapper`. Предполагается, что `MyComponent` содержит кнопку, а следующий код нажимает эту кнопку.
+
+```js
+const wrapper = mount(MyComponent)
+
+wrapper.find('button').trigger('click')
+```
+
+### Опции
+
+Метод `trigger` также может опционально принимать объект `options`. Свойства объекта `options` добавятся к Event.
+
+Обратите внимание, что цель (target) не может добавлена в объект `options`.
+
+
+```js
+const wrapper = mount(MyButton)
+
+wrapper.trigger('click', { button: 0 })
+```
+
+### Пример тестирования кнопки мыши
+
+**Тестируемый компонент**
+
+```html
+
+
+
+
+
+
+
+
+```
+
+**Тест**
+
+```js
+import YesNoComponent from '@/components/YesNoComponent'
+import { mount } from '@vue/test-utils'
+import sinon from 'sinon'
+
+describe('Click event', () => {
+ it('Нажатие на кнопке yes вызывает наш метод с аргументом "yes"', () => {
+ const spy = sinon.spy()
+ const wrapper = mount(YesNoComponent, {
+ propsData: {
+ callMe: spy
+ }
+ })
+ wrapper.find('button.yes').trigger('click')
+
+ spy.should.have.been.calledWith('yes')
+ })
+})
+```
+
+### Пример тестирования клавиши
+
+**Тестируемый компонент**
+
+Этот компонент позволяет увеличивать/уменьшать количество с помощью различных клавиш.
+
+```html
+
+
+
+
+
+```
+
+**Тест**
+
+```js
+import QuantityComponent from '@/components/QuantityComponent'
+import { mount } from '@vue/test-utils'
+
+describe('Тестирование событий клавиш', () => {
+ it('Quantity по умолчанию равно нулю', () => {
+ const wrapper = mount(QuantityComponent)
+ expect(wrapper.vm.quantity).toBe(0)
+ })
+
+ it('Клавиша вверх устанавливает quantity равным 1', () => {
+ const wrapper = mount(QuantityComponent)
+ wrapper.trigger('keydown.up')
+ expect(wrapper.vm.quantity).toBe(1)
+ })
+
+ it('Клавиша вниз уменьшает quantity на 1', () => {
+ const wrapper = mount(QuantityComponent)
+ wrapper.vm.quantity = 5
+ wrapper.trigger('keydown.down')
+ expect(wrapper.vm.quantity).toBe(4)
+ })
+
+ it('Escape устанавливает quantity равным 0', () => {
+ const wrapper = mount(QuantityComponent)
+ wrapper.vm.quantity = 5
+ wrapper.trigger('keydown.esc')
+ expect(wrapper.vm.quantity).toBe(0)
+ })
+
+ it('Магический символ "a" устанавливает quantity равным 13', () => {
+ const wrapper = mount(QuantityComponent)
+ wrapper.trigger('keydown', {
+ which: 65
+ })
+ expect(wrapper.vm.quantity).toBe(13)
+ })
+})
+
+```
+
+**Ограничения**
+
+Имя модификатора после точки `keydown.up` преобразуется в `keyCode`. Это поддерживается для следующих имён:
+
+| key name | key code |
+| --- | --- |
+| enter | 13 |
+| esc | 27 |
+| tab | 9 |
+| space | 32 |
+| delete | 46 |
+| backspace | 8 |
+| insert | 45 |
+| up | 38 |
+| down | 40 |
+| left | 37 |
+| right | 39 |
+| end | 35 |
+| home | 36 |
+| pageup | 33 |
+| pagedown | 34 |
+
+### Важно
+
+Vue Test Utils генерирует событие синхронно. Следовательно, `Vue.nextTick` не требуется.
diff --git a/docs/ru/guides/getting-started.md b/docs/ru/guides/getting-started.md
new file mode 100644
index 000000000..bdf16926c
--- /dev/null
+++ b/docs/ru/guides/getting-started.md
@@ -0,0 +1,144 @@
+## Введение
+
+### Настройка
+
+Для быстрого старта работы с Vue Test Utils, клонируйте наш демонстрационный репозиторий с базовыми настройками и установите зависимости:
+
+``` bash
+git clone https://github.com/vuejs/vue-test-utils-getting-started
+cd vue-test-utils-getting-started
+npm install
+```
+
+Вы увидите, что проект содержит простой компонент `counter.js`:
+
+```js
+// counter.js
+
+export default {
+ template: `
+
+ {{ count }}
+
+
+ `,
+
+ data () {
+ return {
+ count: 0
+ }
+ },
+
+ methods: {
+ increment () {
+ this.count++
+ }
+ }
+}
+```
+
+### Монтирование компонентов
+
+Vue Test Utils тестирует компоненты Vue монтируя их изолированно, создавая моки необходимых входных данных (входные параметры, инъекции и пользовательские события) и выполняя проверки над результатом (результат рендеринга, вызванные пользовательские события).
+
+Примонтированные компоненты возвращаются внутри [Wrapper](../api/wrapper/), который предоставляет множество удобных методов для манипулирования, перемещения и различных запросов для экземпляра компонента Vue.
+
+Вы можете создавать wrapper с помощью метода `mount`. Давайте создадим файл `test.js`:
+
+```js
+// test.js
+
+// Импортируем метод `mount()` из `vue-test-utils`
+// и компонент, который хотим протестировать
+import { mount } from '@vue/test-utils'
+import Counter from './counter'
+
+// Теперь монтируем компонент и у нас появляется wrapper
+const wrapper = mount(Counter)
+
+// Вы можете получить доступ к экземпляру Vue через `wrapper.vm`
+const vm = wrapper.vm
+
+// Чтобы изучить wrapper подробнее, просто выведите его в консоль
+// и ваши приключения с `vue-test-utils` начнутся
+console.log(wrapper)
+```
+
+### Тестирование отрендеренного HTML компонента
+
+Теперь, когда у нас есть wrapper, первой вещью, которую мы можем захотеть проверить что отрендеренный HTML компонента соответствует нашим ожиданиям.
+
+```js
+import { mount } from '@vue/test-utils'
+import Counter from './counter'
+
+describe('Компонент Counter', () => {
+ // Теперь монтируем компонент и получаем wrapper
+ const wrapper = mount(Counter)
+
+ it('отображает корректную разметку', () => {
+ expect(wrapper.html()).toContain('0')
+ })
+
+ // также легко проверить наличие других элементов
+ it('имеет кнопку', () => {
+ expect(wrapper.contains('button')).toBe(true)
+ })
+})
+```
+
+Теперь запустите тесты командой `npm test`. Вы должны увидеть, что все тесты проходят успешно.
+
+### Симуляция пользовательских действий
+
+Наш счётчик должен увеличивать значение, когда пользователь нажимает кнопку. Чтобы симулировать это поведение, нам необходимо сначала получить кнопку с помощью `wrapper.find()`, который возвращает **wrapper для элемента кнопки**. Мы можем симулировать клик с помощью вызова `.trigger()` на wrapper кнопки:
+
+```js
+it('нажатие кнопки должно увеличивать счётчик', () => {
+ expect(wrapper.vm.count).toBe(0)
+ const button = wrapper.find('button')
+ button.trigger('click')
+ expect(wrapper.vm.count).toBe(1)
+})
+```
+
+### Что делать с `nextTick`?
+
+Vue собирает пачку предстоящих обновлений DOM и применяет их асинхронно для избежания ненужных повторных рендерингов, вызываемых множественными изменениями данных. Вот почему на практике на часто приходится использовать `Vue.nextTick` для ожидания, пока Vue не выполнит фактическое обновление DOM после того, как мы инициируем некоторое изменение состояния.
+
+Для упрощения работы, `vue-test-utils` применяет все обновления синхронно, поэтому вам не потребуется использовать `Vue.nextTick` для ожидания обновления DOM в ваших тестах.
+
+*Примечание: `nextTick` по-прежнему необходим, когда вам нужно явно форсировать цикл событий, для таких операций как асинхронные обратные вызовы или разрешение промисов.*
+
+Если вам всё ещё нужно использовать `nextTick` в ваших тестовых файлах, имейте ввиду, что любые ошибки, выброшенные внутри него, могут не быть отловлены вашей программой для запуска тестов, поскольку внутри он реализован на Promise. Существует два подхода исправления этого: либо вы можете установить коллбэк `done` как глобальный обработчик ошибок Vue в начале теста, либо вы можете вызывать `nextTick` без аргумента и вернуть его как Promise:
+
+```js
+// эта ошибка не будет отловлена
+it('ошибка не будет отслеживаться', (done) => {
+ Vue.nextTick(() => {
+ expect(true).toBe(false)
+ done()
+ })
+})
+
+// два следующих теста будут работать как ожидается
+it('должен отлавливать ошибку с использованием done', (done) => {
+ Vue.config.errorHandler = done
+ Vue.nextTick(() => {
+ expect(true).toBe(false)
+ done()
+ })
+})
+
+it('должен отлавливать ошибку с использованием promise', () => {
+ return Vue.nextTick()
+ .then(function () {
+ expect(true).toBe(false)
+ })
+})
+```
+
+### Что дальше
+
+- Интегрируйте `vue-test-utils` в ваш проект выбрав [программу для запуска тестов](./choosing-a-test-runner.md).
+- Прочитайте больше об [общих техниках и советах при написании тестов](./common-tips.md).
diff --git a/docs/ru/guides/testing-SFCs-with-jest.md b/docs/ru/guides/testing-SFCs-with-jest.md
new file mode 100644
index 000000000..54a7eb131
--- /dev/null
+++ b/docs/ru/guides/testing-SFCs-with-jest.md
@@ -0,0 +1,210 @@
+## Тестирование однофайловых компонентов с Jest
+
+> Пример проекта для этой конфигурации доступен на [GitHub](https://github.com/vuejs/vue-test-utils-jest-example).
+
+Jest — это программа для запуска тестов, разработанная Facebook, направленная на предоставление функционального решения для модульного тестирования. Вы можете узнать больше о Jest в [официальной документации](https://facebook.github.io/jest/).
+
+### Установка Jest
+
+Предположим, что вы начинаете с конфигурации, где правильно настроены webpack, vue-loader и Babel — например, развёрнутый шаблон `webpack-simple` с помощью `vue-cli`.
+
+Первым делом нам необходимо установить Jest и `vue-test-utils`:
+
+```bash
+$ npm install --save-dev jest vue-test-utils
+```
+
+Затем, необходимо указать псевдоним для запуска тестов в нашем `package.json`.
+
+```json
+// package.json
+{
+ "scripts": {
+ "test": "jest"
+ }
+}
+```
+
+### Обработка однофайловых компонентов с Jest
+
+Чтобы научить Jest как обрабатывать `*.vue` файлы, нам необходимо установить и настроить пре-процессор `vue-jest`:
+
+``` bash
+npm install --save-dev vue-jest
+```
+
+Теперь, создадим секцию `jest` в файле `package.json`:
+
+``` json
+{
+ // ...
+ "jest": {
+ "moduleFileExtensions": [
+ "js",
+ "json",
+ // сообщаем Jest что необходимо обрабатывать `*.vue` файлы
+ "vue"
+ ],
+ "transform": {
+ // обрабатываем `*.vue` файлы с помощью `vue-jest`
+ ".*\\.(vue)$": "/node_modules/vue-jest"
+ }
+ }
+}
+```
+
+> **Примечание:** `vue-jest` в настоящее время не поддерживает все возможности `vue-loader`, например пользовательские блоки и загрузку стилей. Кроме того, некоторые функции, специфичные для webpack, такие как code-splitting, также не поддерживаются. Чтобы использовать их прочитайте руководство по [тестированию однофайловых компонентов с Mocha + webpack](./testing-SFCs-with-mocha-webpack.md).
+
+### Обработка псевдонимов webpack
+
+Если вы используете псевдонимы в конфигурации webpack, например когда `@` ссылается на путь `/src`, вам также нужно добавить соответствующую конфигурацию для Jest, используя опцию `moduleNameMapper`:
+
+``` json
+{
+ // ...
+ "jest": {
+ // ...
+ // добавление поддержки псевдонима @ -> src в исходном коде
+ "moduleNameMapper": {
+ "^@/(.*)$": "/src/$1"
+ }
+ }
+}
+```
+
+### Конфигурация Babel для Jest
+
+
+Хотя последние версии Node уже поддерживают большинство функций ES2015, вы всё равно можете использовать синтаксис ES-модулей и stage-x функции в ваших тестах. Для этого нужно установить `babel-jest`:
+
+``` bash
+npm install --save-dev babel-jest
+```
+
+Затем мы должны сообщить Jest обрабатывать файлы тестов с JavaScript с помощью `babel-jest`, добавив запись `jest.transform` в `package.json`:
+
+``` json
+{
+ // ...
+ "jest": {
+ // ...
+ "transform": {
+ // ...
+ // обрабатывать js с помощью `babel-jest`
+ "^.+\\.js$": "/node_modules/babel-jest"
+ },
+ // ...
+ }
+}
+```
+
+> По умолчанию `babel-jest` автоматически настраивается по установке. Однако, поскольку мы явно добавили преобразование файлов `*.vue`, нам теперь нужно также настроить `babel-jest`.
+
+Предполагая использование `babel-preset-env` с webpack, конфигурация Babel по умолчанию отключает транспиляцию ES-модулей, потому что webpack уже знает как обрабатывать ES-модули. Однако нам нужно включить его для наших тестов, потому что тесты Jest запускаются непосредственно в Node.
+
+Кроме того, мы можем указать `babel-preset-env` в качестве цели используемую нами версию Node. Это пропустит транспиляцию ненужных функций и ускорит загрузку тестов.
+
+Чтобы применить эти параметры только для тестов, поместите их в отдельную конфигурацию в `env.test` (это будет автоматически обработано `babel-jest`).
+
+Пример `.babelrc`:
+
+``` json
+{
+ "presets": [
+ ["env", { "modules": false }]
+ ],
+ "env": {
+ "test": {
+ "presets": [
+ ["env", { "targets": { "node": "current" }}]
+ ]
+ }
+ }
+}
+```
+
+### Тестирование моментальными снимками
+
+Вы можете использовать [`vue-server-renderer`](https://github.com/vuejs/vue/tree/dev/packages/vue-server-renderer) для рендеринга компонента в строку, чтобы его можно было сохранить в качестве снимка для [тестирования моментальными снимками в Jest](https://facebook.github.io/jest/docs/en/snapshot-testing.html).
+
+Результат рендеринга `vue-server-renderer` включает в себя несколько атрибутов, специфичных для SSR, и игнорирует пробелы, что затрудняет сравнивать diff. Мы можем улучшить сохранённый снимок с помощью специального сериализатора:
+
+``` bash
+npm install --save-dev jest-serializer-vue
+```
+
+Затем добавьте конфигурацию в `package.json`:
+
+``` json
+{
+ // ...
+ "jest": {
+ // ...
+ // сериализатор для снимков
+ "snapshotSerializers": [
+ "/node_modules/jest-serializer-vue"
+ ]
+ }
+}
+```
+
+### Расположение файлов тестов
+
+По умолчанию Jest будет рекурсивно выбирать все файлы с расширением `.spec.js` или `.test.js` во всём проекте. Если это поведение не соответствует вашим потребностям, то возможно [изменить `testRegex`](https://facebook.github.io/jest/docs/en/configuration.html#testregex-string) в секции конфигурации в файле `package.json`.
+
+Jest рекомендует создать каталог `__tests__` рядом с тестируемым кодом, но не стесняйтесь структурировать ваши тесты по своему усмотрению. Просто остерегайтесь того, что Jest создаст каталог `__snapshots__` рядом с тестовыми файлами, который необходим для тестирования с помощью моментальных снимков.
+
+### Покрытие кода (Coverage)
+
+Jest может быть использован для генерации отчётов о покрытии кода в нескольких форматах. Ниже приведён простой пример для начала:
+
+Расширьте вашу конфигурацию `jest` (обычно расположенную в `package.json` или `jest.config.js`) с помощью опции [collectCoverage](https://facebook.github.io/jest/docs/en/configuration.html#collectcoverage-boolean), и затем добавьте массив [collectCoverageFrom](https://facebook.github.io/jest/docs/en/configuration.html#collectcoveragefrom-array) для определения файлов, для которых требуется собирать информацию о покрытии.
+
+```json
+{
+ "jest": {
+ // ...
+ "collectCoverage": true,
+ "collectCoverageFrom": [
+ "**/*.{js,vue}",
+ "!**/node_modules/**"
+ ]
+ }
+}
+```
+
+Это включит отчёты о покрытии с использованием [стандартных отчётов о покрытии](https://facebook.github.io/jest/docs/en/configuration.html#coveragereporters-array-string). Вы можете настроить их с помощью опции `coverageReporters`:
+
+```json
+{
+ "jest": {
+ // ...
+ "coverageReporters": ["html", "text-summary"]
+ }
+}
+```
+
+Дополнительную информацию можно найти в [документации по конфигурации Jest](https://facebook.github.io/jest/docs/en/configuration.html#collectcoverage-boolean), где вы можете найти параметры для пороговых значений покрытия, каталоги вывода данных и т.д.
+
+### Пример спецификации
+
+Если вы знакомы с Jasmine, то вы должны чувствовать себя как дома с [проверочным API](https://facebook.github.io/jest/docs/en/expect.html#content) Jest:
+
+```js
+import { mount } from '@vue/test-utils'
+import Component from './component'
+
+describe('Component', () => {
+ test('является экземпляром Vue', () => {
+ const wrapper = mount(Component)
+ expect(wrapper.isVueInstance()).toBeTruthy()
+ })
+})
+```
+
+### Ресурсы
+
+- [Пример проекта для этой конфигурации](https://github.com/vuejs/vue-test-utils-jest-example)
+- [Примеры и слайды с Vue Conf 2017](https://github.com/codebryo/vue-testing-with-jest-conf17)
+- [Jest](https://facebook.github.io/jest/)
+- [Babel preset env](https://github.com/babel/babel-preset-env)
diff --git a/docs/ru/guides/testing-SFCs-with-karma.md b/docs/ru/guides/testing-SFCs-with-karma.md
new file mode 100644
index 000000000..2ef2c6dd3
--- /dev/null
+++ b/docs/ru/guides/testing-SFCs-with-karma.md
@@ -0,0 +1,202 @@
+## Тестирование однофайловых компонентов с Karma
+
+> Пример проекта для этой конфигурации доступен на [GitHub](https://github.com/eddyerburgh/vue-test-utils-karma-example).
+
+Karma — это программа для запуска тестов, которая открывает браузеры, выполняет тесты и сообщает нам об их результатах. Мы собираемся использовать фреймворк Mocha для написания тестов. Мы будем использовать библиотеку chai для тестовых утверждений.
+
+### Установка Mocha
+
+Предположим, что вы начинаете с конфигурации, где правильно настроены webpack, vue-loader и Babel — например, развёрнутый шаблон `webpack-simple` с помощью `vue-cli`.
+
+Первым делом нам необходимо установить тестовые зависимости:
+
+``` bash
+npm install --save-dev @vue/test-utils karma karma-chrome-launcher karma-mocha karma-sourcemap-loader karma-spec-reporter karma-webpack mocha
+```
+
+Далее нам нужно определить скрипт для запуска тестов в `package.json`.
+
+```json
+// package.json
+{
+ "scripts": {
+ "test": "karma start --single-run"
+ }
+}
+```
+
+- Флаг `--single-run` указывает Karma запускать набор тестов только один раз.
+
+### Karma Configuration
+
+Создайте файл `karma.conf.js` в корне вашего проекта:
+
+```js
+// karma.conf.js
+
+var webpackConfig = require('./webpack.config.js')
+
+module.exports = function (config) {
+ config.set({
+ frameworks: ['mocha'],
+
+ files: [
+ 'test/**/*.spec.js'
+ ],
+
+ preprocessors: {
+ '**/*.spec.js': ['webpack', 'sourcemap']
+ },
+
+ webpack: webpackConfig,
+
+ reporters: ['spec'],
+
+ browsers: ['Chrome']
+ })
+}
+```
+
+Этот файл используется для настройки Karma.
+
+Нам нужно предварительно обработать файлы с помощью webpack. Для этого мы добавляем webpack в качестве препроцессора и включаем нашу конфигурацию webpack. Мы можем использовать конфигурационный файл webpack в корне проекте, ничего не меняя.
+
+В нашей конфигурации мы запускаем тесты в Chrome. Для добавления дополнительных браузеров смотрите [раздел Браузеры в документации Karma](http://karma-runner.github.io/2.0/config/browsers.html).
+
+### Выбор библиотеки утверждений
+
+[Chai](http://chaijs.com/) - популярная библиотека утверждений, которая обычно используется вместе с Mocha. Вы посмотреть на [Sinon](http://sinonjs.org/) для создания шпионов и заглушек.
+
+Мы можем установить плагин `karma-chai` для использования `chai` в наших тестах.
+
+``` bash
+npm install --save-dev karma-chai
+```
+
+### Добавление теста
+
+Создайте в каталоге `src` файл с именем `Counter.vue`:
+
+``` html
+
+
+ {{ count }}
+
+
+
+
+
+```
+
+И создайте файл `test/Counter.spec.js` со следующим кодом:
+
+```js
+import { expect } from 'chai'
+import { shallowMount } from '@vue/test-utils'
+import Counter from '../src/Counter.vue'
+
+describe('Counter.vue', () => {
+ it('increments count when button is clicked', () => {
+ const wrapper = shallowMount(Counter)
+ wrapper.find('button').trigger('click')
+ expect(wrapper.find('div').text()).contains('1')
+ })
+})
+```
+
+И теперь мы можем запустить тесты:
+
+```
+npm run test
+```
+
+Ура, наши тесты работают!
+
+### Покрытие кода
+
+Для настройки покрытия кода Karma, мы можем использовать плагин `karma-coverage`.
+
+По умолчанию `karma-coverage` не будет использовать исходные карты для отображения отчётов о покрытии. Поэтому нам нужно использовать `babel-plugin-istanbul`, чтобы убедиться, что покрытие правильно работает.
+
+Установите `karma-coverage`, `babel-plugin-istanbul` и `cross-env`:
+
+```
+npm install --save-dev karma-coverage cross-env
+```
+
+Мы собираемся использовать `cross-env` для установки переменной окружения `BABEL_ENV`. Таким образом, мы можем использовать `babel-plugin-istanbul` при компиляции наших тестов — мы не хотим включать `babel-plugin-istnabul` при компиляции нашего кода в production:
+
+```
+npm install --save-dev babel-plugin-istanbul
+```
+
+Обновите файл `.babelrc` для использования `babel-plugin-istanbul`, когда `BABEL_ENV` равняется test:
+
+```json
+{
+ "presets": [
+ ["env", { "modules": false }],
+ "stage-3"
+ ],
+ "env": {
+ "test": {
+ "plugins": ["istanbul"]
+ }
+ }
+}
+```
+
+Теперь обновите файл `karma.conf.js` для использования покрытия кода. Добавьте `coverage` в массив `reporters` и добавьте поле `coverageReporter`:
+
+```js
+// karma.conf.js
+
+module.exports = function (config) {
+ config.set({
+ // ...
+
+ reporters: ['spec', 'coverage'],
+
+ coverageReporter: {
+ dir: './coverage',
+ reporters: [
+ { type: 'lcov', subdir: '.' },
+ { type: 'text-summary' }
+ ]
+ }
+ })
+}
+```
+
+И обновите тестовый скрипт `test` для установки `BABEL_ENV`:
+
+```json
+// package.json
+{
+ "scripts": {
+ "test": "cross-env BABEL_ENV=test karma start --single-run"
+ }
+}
+```
+
+### Ресурсы
+
+- [Пример проекта для этой конфигурации](https://github.com/eddyerburgh/vue-test-utils-karma-example)
+- [Karma](http://karma-runner.github.io/)
+- [Mocha](https://mochajs.org/)
+- [Chai](http://chaijs.com/)
+- [Sinon](http://sinonjs.org/)
diff --git a/docs/ru/guides/testing-SFCs-with-mocha-webpack.md b/docs/ru/guides/testing-SFCs-with-mocha-webpack.md
new file mode 100644
index 000000000..91d791c72
--- /dev/null
+++ b/docs/ru/guides/testing-SFCs-with-mocha-webpack.md
@@ -0,0 +1,184 @@
+## Тестирование однофайловых компонентов с Mocha + webpack
+
+> Пример проекта для этой конфигурации доступен на [GitHub](https://github.com/vuejs/vue-test-utils-mocha-webpack-example).
+
+Другая стратегия тестирования однофайловых компонентов заключается в компиляции всех наших тестов с помощью webpack, а затем программой для запуска тестов. Преимущество такого подхода заключается в том, что он даёт нам полную поддержку всех функций webpack и `vue-loader`, поэтому нам не нужно идти на компромиссы в нашем исходном коде.
+
+Технически, вы можете использовать любую программу для запуска тестов, которая вам нравится, и вручную соединять вещи, но мы нашли [`mocha-webpack`](https://github.com/zinserjan/mocha-webpack) как очень удобный способ для реализации этой задачи.
+
+### Настройка `mocha-webpack`
+
+Мы предположим, что вы начинаете с настройки, когда уже есть правильно настроенные webpack, vue-loader и Babel — например используя шаблон `webpack-simple`, развёрнутый с помощью `vue-cli`.
+
+Первое, что нужно сделать, это установить тестовые зависимости:
+
+``` bash
+npm install --save-dev @vue/test-utils mocha mocha-webpack
+```
+
+Затем мы должны указать скрипт test в нашем `package.json`.
+
+```json
+// package.json
+{
+ "scripts": {
+ "test": "mocha-webpack --webpack-config webpack.config.js --require test/setup.js test/**/*.spec.js"
+ }
+}
+```
+
+Несколько вещей, о том что мы сделали:
+
+- Флаг `--webpack-config` указывает конфигурационный файл webpack для использования в тестах. В большинстве случаев это будут идентичная конфигурация, используемой в проекте, с одной небольшой доработкой. Мы поговорим об этом позднее.
+
+- Флаг `--require` гарантирует, что файл `test/setup.js` будет запущен перед любыми тестами, в котором мы можем настроить для наших тестов глобальное окружение, в котором они будут запускаться.
+
+- Последний аргумент — это шаблон для тестовых файлов, которые будут включены в тестовую сборку.
+
+### Дополнительная конфигурация webpack
+
+#### Вынесение внешних NPM-зависимостей
+
+В наших тестах мы, скорее всего, импортируем ряд NPM-зависимостей — некоторые из этих модулей могут быть написаны не для использования в браузере и просто не смогут быть корректно добавлены в сборку webpack. Другой плюс в том, что извлечение внешних зависимостей значительно улучшит скорость загрузки тестов. Мы можем вынести все NPM-зависимости с помощью `webpack-node-externals`:
+
+```js
+// webpack.config.js
+const nodeExternals = require('webpack-node-externals')
+
+module.exports = {
+ // ...
+ externals: [nodeExternals()]
+}
+```
+
+#### Source Maps
+
+Source maps должны быть встроены для использования в `mocha-webpack`. Рекомендуемая конфигурация:
+
+``` js
+module.exports = {
+ // ...
+ devtool: 'inline-cheap-module-source-map'
+}
+```
+
+При отладке через IDE рекомендуется также добавить следующее:
+
+``` js
+module.exports = {
+ // ...
+ output: {
+ // ...
+ // использовать абсолютные пути в sourcemaps (важно для отладки через IDE)
+ devtoolModuleFilenameTemplate: '[absolute-resource-path]',
+ devtoolFallbackModuleFilenameTemplate: '[absolute-resource-path]?[hash]'
+ }
+}
+```
+
+### Настройка браузерного окружения
+
+`vue-test-utils` требует браузерного окружения для запуска. Мы можем симулировать его в Node используя `jsdom-global`:
+
+```bash
+npm install --save-dev jsdom jsdom-global
+```
+
+Затем в `test/setup.js`:
+
+``` js
+require('jsdom-global')()
+```
+
+Это добавит браузерное окружение в Node, таким образом `vue-test-utils` сможет корректно запуститься.
+
+### Выбор библиотеки утверждений
+
+[Chai](http://chaijs.com/) — популярная библиотека утверждений, которая обычно используется вместе с Mocha. Вы также можете воспользоваться [Sinon](http://sinonjs.org/) для создания шпионов и заглушек.
+
+В качестве альтернативы вы можете использовать `expect`, который является частью Jest и реализует [точно такой же API](http://facebook.github.io/jest/docs/en/expect.html#content) в документации Jest.
+
+Мы будем использовать `expect` здесь и сделаем его глобально доступным, чтобы нам не приходилось импортировать его в каждом тесте:
+
+``` bash
+npm install --save-dev expect
+```
+
+Затем в `test/setup.js`:
+
+``` js
+require('jsdom-global')()
+
+global.expect = require('expect')
+```
+
+### Оптимизация Babel для тестов
+
+Обратите внимание, что мы используем `babel-loader` для обработки JavaScript. У вас уже должен быть настроен Babel, если вы используете его в своём приложении, через файл `.babelrc`. Здесь `babel-loader` будет автоматически использовать тот же файл конфигурации.
+
+Следует отметить, что если вы используете Node 6+, которая уже поддерживает большинство функций ES2015, вы можете настроить отдельную [опцию env](https://babeljs.io/docs/usage/babelrc/#env-option) Babel, которая будет транспилировать только те функции, которые ещё не поддерживаются в используемой версии Node (например, `stage-2` или поддержку синтаксиса flow, и т.п.).
+
+### Добавление теста
+
+Создайте файл в `src` названный `Counter.vue`:
+
+``` html
+
+
+ {{ count }}
+
+
+
+
+
+```
+
+И создайте файл теста, названный `test/Counter.spec.js` со следующим кодом:
+
+```js
+import { shallowMount } from '@vue/test-utils'
+import Counter from '../src/Counter.vue'
+
+describe('Counter.vue', () => {
+ it('увеличивает счётчик по нажатию кнопки', () => {
+ const wrapper = shallowMount(Counter)
+ wrapper.find('button').trigger('click')
+ expect(wrapper.find('div').text()).toMatch('1')
+ })
+})
+```
+
+И теперь мы можем запустить тест:
+
+```
+npm run test
+```
+
+Ура, мы запустили наши тесты!
+
+### Покрытие кода (Coverage)
+
+Для настройки покрытия кода в mocha-webpack, следуйте [инструкции по настройке покрытия кода mocha-webpack](https://github.com/zinserjan/mocha-webpack/blob/master/docs/guides/code-coverage.md).
+
+### Ресурсы
+
+- [Пример проекта для этой настройки](https://github.com/vuejs/vue-test-utils-mocha-webpack-example)
+- [Mocha](https://mochajs.org/)
+- [mocha-webpack](http://zinserjan.github.io/mocha-webpack/)
+- [Chai](http://chaijs.com/)
+- [Sinon](http://sinonjs.org/)
+- [jest/expect](http://facebook.github.io/jest/docs/en/expect.html#content)
diff --git a/docs/ru/guides/testing-async-components.md b/docs/ru/guides/testing-async-components.md
new file mode 100644
index 000000000..6c9febc36
--- /dev/null
+++ b/docs/ru/guides/testing-async-components.md
@@ -0,0 +1,97 @@
+## Тестирование асинхронной логики
+
+Чтобы упростить тестирование, `vue-test-utils` применяет обновления DOM _синхронно_. Однако, есть некоторые тонкости, когда вам необходимо протестировать компонент с асинхронным поведением, таким как коллбэки или промисы.
+
+Одними из самых распространённых поведений являются запросы к API и действия Vuex. В примерах ниже будет показано как протестировать метод, который делает запрос к API. В этом примере используется Jest для запуска тестов и мок для HTTP-библиотеки `axios`. Подробнее о использовании моков в Jest можно прочитать [здесь](https://facebook.github.io/jest/docs/en/manual-mocks.html#content).
+
+Реализация мока для `axios` выглядит так:
+
+``` js
+export default {
+ get: () => new Promise(resolve => {
+ resolve({ data: 'value' })
+ })
+}
+```
+
+Компонент ниже делает вызов к API при нажатии кнопки и сохраняет полученный ответ в `value`.
+
+``` html
+
+
+
+
+
+```
+
+Тест можно написать следующим образом:
+
+``` js
+import { shallowMount } from '@vue/test-utils'
+import Foo from './Foo'
+jest.mock('axios')
+
+test('Foo', () => {
+ it('делает асинхронный запрос при нажатии кнопки', () => {
+ const wrapper = shallowMount(Foo)
+ wrapper.find('button').trigger('click')
+ expect(wrapper.vm.value).toBe('value')
+ })
+})
+```
+
+В настоящее время этот тест не будет успешно проходить, потому что проверка значения вызывается до разрешения промиса `fetchResults`. Большинство библиотек для модульного тестирования предоставляют коллбэк, чтобы предоставить возможность определять когда тест должен будет завершаться. Jest и Mocha используют `done`. Мы можем использовать `done` в комбинации с `$nextTick` или `setTimeout`, чтобы гарантировать, что любые промисы будут разрешены перед проверками.
+
+``` js
+test('Foo', () => {
+ it('делает асинхронный запрос при нажатии кнопки', (done) => {
+ const wrapper = shallowMount(Foo)
+ wrapper.find('button').trigger('click')
+ wrapper.vm.$nextTick(() => {
+ expect(wrapper.vm.value).toBe('value')
+ done()
+ })
+ })
+})
+```
+
+Необходимость `$nextTick` или `setTimeout` требуется для прохождения теста, потому что очередь микрозадач, в которой обрабатываются промисы, обрабатывается до очереди задач, где обрабатываются `$nextTick` и `setTimeout`. Это означает, что к моменту запуска `$nexTick` и `setTimeout`, будут выполнены любые коллбэки промисов. См. [здесь](https://jakearchibald.com/2015/tasks-microtasks-queues-and-schedules/) для более подробного объяснения.
+
+Другое решение — использовать `async` функцию и npm-пакет `flush-promises`. `flush-promises` сбрасывает все ожидаемые промисы. Вы можете использовать `await` вызов для `flushPromises` чтобы очистить все ожидаемые промисы и улучшить читаемость вашего теста.
+
+Обновлённый тест будет выглядеть так:
+
+``` js
+import { shallowMount } from '@vue/test-utils'
+import flushPromises from 'flush-promises'
+import Foo from './Foo'
+jest.mock('axios')
+
+test('Foo', () => {
+ it('делает асинхронный запрос при нажатии кнопки', async () => {
+ const wrapper = shallowMount(Foo)
+ wrapper.find('button').trigger('click')
+ await flushPromises()
+ expect(wrapper.vm.value).toBe('value')
+ })
+})
+```
+
+Подобная техника может применяться и для действий Vuex, которые возвращают promise по умолчанию.
diff --git a/docs/ru/guides/using-with-vue-router.md b/docs/ru/guides/using-with-vue-router.md
new file mode 100644
index 000000000..5e78ab687
--- /dev/null
+++ b/docs/ru/guides/using-with-vue-router.md
@@ -0,0 +1,81 @@
+## Использование с Vue Router
+
+### Установка Vue Router в тестах
+
+Вы никогда не должны устанавливать Vue Router в базовый конструктор Vue в тестах. Установка Vue Router добавляет `$route` и `$router` как свойства только для чтения на прототипе Vue.
+
+Чтобы этого избежать, мы можем создать localVue и установить Vue Router на него.
+
+```js
+import { shallowMount, createLocalVue } from '@vue/test-utils'
+import VueRouter from 'vue-router'
+
+const localVue = createLocalVue()
+localVue.use(VueRouter)
+const router = new VueRouter()
+
+shallowMount(Component, {
+ localVue,
+ router
+})
+```
+
+> **Примечание:** Установка Vue Router на `localVue` также добавляет `$route` и `$router` в качестве свойство только для чтения `localVue`. Это означает, что вы можете использовать опцию `mocks` для перезаписи `$route` и `$router` при монтировании компонента, используя `localVue` с установленным Vue Router.
+
+### Тестирование компонентов использующих `router-link` или `router-view`
+
+Когда вы устанавливаете Vue Router, регистрируются глобальные компоненты `router-link` и `router-view`. Это означает, что мы можем использовать их в любом месте нашего приложения без необходимости импортировать их.
+
+Когда мы запускаем тесты, нам нужно сделать эти компоненты vue-router доступными для компонента, который мы монтируем. Есть два способа сделать это.
+
+#### Использование заглушек (stubs)
+
+```js
+import { shallowMount } from '@vue/test-utils'
+
+shallowMount(Component, {
+ stubs: ['router-link', 'router-view']
+})
+```
+
+#### Установка Vue Router с помощью localVue
+
+```js
+import { shallowMount, createLocalVue } from '@vue/test-utils'
+import VueRouter from 'vue-router'
+
+const localVue = createLocalVue()
+localVue.use(VueRouter)
+
+shallowMount(Component, {
+ localVue
+})
+```
+
+### Создание моков `$route` и `$router`
+
+Иногда вам может потребоваться протестировать, что компонент что-то делает с параметрами объектов `$route` и `$router`. Для этого вы можете передавать пользовательские моки в экземпляр Vue.
+
+```js
+import { shallowMount } from '@vue/test-utils'
+
+const $route = {
+ path: '/some/path'
+}
+
+const wrapper = shallowMount(Component, {
+ mocks: {
+ $route
+ }
+})
+
+wrapper.vm.$route.path // /some/path
+```
+
+### Известные подводные камни
+
+Установка Vue Router добавляет `$route` и `$router` в качестве свойств только для чтения на прототипе Vue.
+
+Это означет, что любые будущие тесты, которые попытаются сделать мок `$route` или `$router` потерпят неудачу.
+
+Для избежания этого никогда не устанавливайте Vue Router глобально при запуске тестов; используйте localVue как было показано выше.
diff --git a/docs/ru/guides/using-with-vuex.md b/docs/ru/guides/using-with-vuex.md
new file mode 100644
index 000000000..d5e064ab0
--- /dev/null
+++ b/docs/ru/guides/using-with-vuex.md
@@ -0,0 +1,392 @@
+## Использование с Vuex
+
+В этом руководстве мы рассмотрим как тестировать Vuex в компонентах с Vue Test Utils и как подходить к тестированию хранилища Vuex.
+
+## Тестирование Vuex в компонентах
+
+### Создание моков для действий
+
+Давайте посмотрим на часть кода.
+
+Это компонент который мы хотим протестировать. Он вызывает действие Vuex.
+
+``` html
+
+
+
+
+
+
+
+
+```
+
+Для целей этого теста нам всё равно, что делает действие или как выглядит структура хранилища. Мы должны просто узнать, что это действие вызывается когда должно, и что оно вызывается с ожидаемым значением.
+
+Чтобы протестировать это, нам нужно передать мок хранилища в Vue, когда мы отделяем наш компонент.
+
+Вместо передачи хранилища в базовый конструктор Vue, мы можем передать его в [localVue](../api/options.md#localvue). localVue — это изолированный конструктор Vue, в который мы можем вносить изменения без влияния на глобальный конструктор Vue.
+
+Давайте посмотрим, как это выглядит:
+
+``` js
+import { shallowMount, createLocalVue } from '@vue/test-utils'
+import Vuex from 'vuex'
+import Actions from '../../../src/components/Actions'
+
+const localVue = createLocalVue()
+
+localVue.use(Vuex)
+
+describe('Actions.vue', () => {
+ let actions
+ let store
+
+ beforeEach(() => {
+ actions = {
+ actionClick: jest.fn(),
+ actionInput: jest.fn()
+ }
+ store = new Vuex.Store({
+ state: {},
+ actions
+ })
+ })
+
+ it('вызывает "actionInput", когда значение события — "input"', () => {
+ const wrapper = shallowMount(Actions, { store, localVue })
+ const input = wrapper.find('input')
+ input.element.value = 'input'
+ input.trigger('input')
+ expect(actions.actionInput).toHaveBeenCalled()
+ })
+
+ it('не вызывает "actionInput", когда значение событие не "input"', () => {
+ const wrapper = shallowMount(Actions, { store, localVue })
+ const input = wrapper.find('input')
+ input.element.value = 'not input'
+ input.trigger('input')
+ expect(actions.actionInput).not.toHaveBeenCalled()
+ })
+
+ it('вызывает действие хранилища "actionClick" по нажатию кнопки', () => {
+ const wrapper = shallowMount(Actions, { store, localVue })
+ wrapper.find('button').trigger('click')
+ expect(actions.actionClick).toHaveBeenCalled()
+ })
+})
+```
+
+Что тут происходит? Сначала мы указываем Vue использовать Vuex с помощью метода `localVue.use`. Это всего лишь обёртка вокруг `Vue.use`.
+
+Затем мы создаём мок хранилища вызовом `new Vuex.store` с нашими заготовленными значениями. Мы передаём ему только действия, так как это всё, что нам необходимо.
+
+Действия реализуются с помощью [mock-функций jest](https://facebook.github.io/jest/docs/en/mock-functions.html). Эти mock-функции предоставляют нам методы для проверки, вызывались ли действия или нет.
+
+Затем мы можем проверить в наших тестах, что заглушка действия была вызвана когда ожидалось.
+
+Теперь способ, которым мы определяем наше хранилище выглядит немного необычным для вас.
+
+Мы используем `beforeEach`, чтобы убедиться, что у нас есть чистое хранилище перед каждым тестом. `beforeEach` — это хук в mocha, который вызывается перед каждым тестом. В нашем тесте мы переназначаем значения переменных хранилища. Если бы мы этого не сделали, mock-функции нужно было бы автоматически сбрасывать. Это также позволяет нам изменять состояние в наших тестах, не влияя на последующие тесты.
+
+Самое важно, что следует отметить в этом тесте — то что **мы создаём мок хранилища Vuex и затем передаём его в `vue-test-utils`**.
+
+Отлично, теперь мы можем создавать моки действий, давайте посмотрим на создание моков для геттеров.
+
+### Создание моков для геттеров
+
+
+``` html
+
+
+
{{inputValue}}
+
{{clicks}}
+
+
+
+
+```
+
+Это довольно простой компонент. Он отображает результат геттеров `clicks` и `inputValue`. Опять же, нас не волнует что возвращают эти геттеры — только то, что их результат будет корректно отображён.
+
+Давайте посмотрим на тест:
+
+``` js
+import { shallowMount, createLocalVue } from '@vue/test-utils'
+import Vuex from 'vuex'
+import Getters from '../../../src/components/Getters'
+
+const localVue = createLocalVue()
+
+localVue.use(Vuex)
+
+describe('Getters.vue', () => {
+ let getters
+ let store
+
+ beforeEach(() => {
+ getters = {
+ clicks: () => 2,
+ inputValue: () => 'input'
+ }
+
+ store = new Vuex.Store({
+ getters
+ })
+ })
+
+ it('Отображает "state.inputValue" в первом теге p', () => {
+ const wrapper = shallowMount(Getters, { store, localVue })
+ const p = wrapper.find('p')
+ expect(p.text()).toBe(getters.inputValue())
+ })
+
+ it('Отображает "state.clicks" во втором теге p', () => {
+ const wrapper = shallowMount(Getters, { store, localVue })
+ const p = wrapper.findAll('p').at(1)
+ expect(p.text()).toBe(getters.clicks().toString())
+ })
+})
+```
+
+Этот тест очень похож на тест действий. Мы создаём мок хранилища перед каждым тестом, передаём его в качестве опции когда вызываем `shallowMount`, и проверяем что значение вернувшееся из мока-геттера отображается.
+
+Это здорово, но что, если мы хотим проверить, что наши геттеры возвращают корректную часть нашего состояния?
+
+### Создание моков с модулями
+
+[Модули](https://vuex.vuejs.org/ru/modules.html) полезны для разделения нашего хранилища на управляемые части. Они также экспортируют геттеры. Мы можем использовать их в наших тестах.
+
+Давайте взглянем на наш компонент:
+
+``` html
+
+
+
+
{{moduleClicks}}
+
+
+
+
+```
+
+Простой компонент, который содержит одно действие и один геттер.
+
+И тест:
+
+``` js
+import { shallowMount, createLocalVue } from '@vue/test-utils'
+import Vuex from 'vuex'
+import MyComponent from '../../../src/components/MyComponent'
+import myModule from '../../../src/store/myModule'
+
+const localVue = createLocalVue()
+
+localVue.use(Vuex)
+
+describe('MyComponent.vue', () => {
+ let actions
+ let state
+ let store
+
+ beforeEach(() => {
+ state = {
+ clicks: 2
+ }
+
+ actions = {
+ moduleActionClick: jest.fn()
+ }
+
+ store = new Vuex.Store({
+ modules: {
+ myModule: {
+ state,
+ actions,
+ getters: myModule.getters
+ }
+ }
+ })
+ })
+
+ it('вызывает действие "moduleActionClick" при нажатии кнопки', () => {
+ const wrapper = shallowMount(MyComponent, { store, localVue })
+ const button = wrapper.find('button')
+ button.trigger('click')
+ expect(actions.moduleActionClick).toHaveBeenCalled()
+ })
+
+ it('отображает "state.inputValue" в первом теге p', () => {
+ const wrapper = shallowMount(MyComponent, { store, localVue })
+ const p = wrapper.find('p')
+ expect(p.text()).toBe(state.clicks.toString())
+ })
+})
+```
+
+### Тестирование хранилища Vuex
+
+Существуют два подхода к тестированию хранилища Vuex. Первый подход заключается в модульном тестировании геттеров, изменений и действий отдельно. Второй подход — создать хранилище и протестировать его. Мы рассмотрим оба подхода.
+
+Чтобы понять, как протестировать хранилище Vuex, мы создадим простое хранилище-счетчик. В хранилище есть мутация `increment` и геттер `evenOrOdd`.
+
+```js
+// mutations.js
+export default {
+ increment (state) {
+ state.count++
+ }
+}
+```
+
+```js
+// getters.js
+export default {
+ evenOrOdd: state => state.count % 2 === 0 ? 'even' : 'odd'
+}
+```
+
+### Тестирование геттеров, мутаций и действий отдельно
+
+Геттеры, мутации и действия — JavaScript-функции, поэтому мы можем протестировать их без использования Vue Test Utils и Vuex.
+
+Преимущество тестирования геттеров, мутаций и действий по отдельности заключается в том, как ваши модульные тесты подробно описаны. Когда они терпят неудачу, вы точно знаете, что не так с вашим кодом. Недостатком является то, что вы нужны моки функций Vuex, таких как `commit` и `dispatch`. Это может привести к ситуации, когда модульные тесты проходят, но production-код терпит неудачу, потому что моки некорректные.
+
+Мы создадим два тестовых файла: `mutations.spec.js` и `getters.spec.js`:
+
+Сначала давайте протестируем мутации `increment`:
+
+```js
+// mutations.spec.js
+
+import mutations from './mutations'
+
+test('increment increments state.count by 1', () => {
+ const state = {
+ count: 0
+ }
+ mutations.increment(state)
+ expect(state.count).toBe(1)
+})
+```
+
+Теперь давайте протестируем геттер `evenOrOdd`. Мы можем протестировать его, путём создания мока для `state`, вызвав геттер с `state` и проверкой, что возвращается корректное значение.
+
+```js
+// getters.spec.js
+
+import getters from './getters'
+
+test('evenOrOdd возвращает even, если в state.count находится even', () => {
+ const state = {
+ count: 2
+ }
+ expect(getters.evenOrOdd(state)).toBe('even')
+})
+
+test('evenOrOdd возвращает odd, если в state.count находится odd', () => {
+ const state = {
+ count: 1
+ }
+ expect(getters.evenOrOdd(state)).toBe('odd')
+})
+
+```
+
+### Тестирование запущенного хранилища
+
+Другой подход к тестированию хранилища Vuex — это создание запущенного хранилища с использованием конфигурации хранилища.
+
+Преимущество тестирования создания экземпляра запущенного хранилища заключается в том,что нам не нужны моки для функций Vuex.
+
+Недостатком является то, что если тест ломается, может быть трудно найти, в чём проблема.
+
+Давайте напишем тест. Когда мы создаем, мы будем использовать `localVue`, чтобы избежать загрязнения базового конструктора Vue. Тест создает хранилище, используя экспорт `store-config.js`:
+
+```js
+// store-config.spec.js
+
+import mutations from './mutations'
+import getters from './getters'
+
+export default {
+ state: {
+ count: 0
+ },
+ mutations,
+ getters
+}
+```
+
+```js
+import { createLocalVue } from '@vue/test-utils'
+import Vuex from 'vuex'
+import storeConfig from './store-config'
+import { cloneDeep } from 'lodash'
+
+test('инкрементирует значение счетчика, когда происходит инкремент', () => {
+ const localVue = createLocalVue()
+ localVue.use(Vuex)
+ const store = new Vuex.Store(cloneDeep(storeConfig))
+ expect(store.state.count).toBe(0)
+ store.commit('increment')
+ expect(store.state.count).toBe(1)
+})
+
+test('обновляет геттер evenOrOdd, когда происходит инкремент', () => {
+ const localVue = createLocalVue()
+ localVue.use(Vuex)
+ const store = new Vuex.Store(cloneDeep(storeConfig))
+ expect(store.getters.evenOrOdd).toBe('even')
+ store.commit('increment')
+ expect(store.getters.evenOrOdd).toBe('odd')
+})
+```
+
+Обратите внимание, что мы используем `cloneDeep` дял клонирования конфигурации хранилища перед созанием храналища с ним. Это связано с тем, что Vuex мутирует объект с опциями, используемый для создания хранилища. Чтобы убедиться, у нас есть пустое хранилище в каждом тесте, нам нужно клонировать объект `storeConfig`.
+
+### Ресурсы
+
+- [Пример проекта тестирования компонентов](https://github.com/eddyerburgh/vue-test-utils-vuex-example)
+- [Пример проекта тестирования хранилища](https://github.com/eddyerburgh/testing-vuex-store-example)
+- [`localVue`](../api/options.md#localvue)
+- [`createLocalVue`](../api/createLocalVue.md)
\ No newline at end of file