diff --git a/es_ES/docs/recipes/react.md b/es_ES/docs/recipes/react.md
index cc61ded5..d3e52c28 100644
--- a/es_ES/docs/recipes/react.md
+++ b/es_ES/docs/recipes/react.md
@@ -1,149 +1,149 @@
-___
-**Nota del traductor**
-
-Esta es la traducción del archivo [react.md](https://github.com/avajs/ava/blob/master/react.md). Aquí hay un [enlace](https://github.com/avajs/ava/compare/8e2f3dca177a4283ad882596d3c1425cabb998ef...master#diff-60cce07a584082115d230f2e3d571ad6) a las diferencias con la rama master de AVA (Si al hacer click en el enlace no se encuentran modificaciones en el archivo `react.md`, será por que la traducción está actualizada).
-___
-# Testeando componentes de React
-
-Traducciones: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/react.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/react.md)
-
-## Configurando Babel
-
-El primer paso es configurar Babel para transiplar el código JSX de los tests añadiendo una sección para ava en tu `package.json`:
-
-```json
-{
-  "ava": {
-    "require": ["babel-register"],
-    "babel": "inherit"
-  },
-  "babel": {
-    "presets": ["react"]
-  }
-}
-```
-
-Puedes encontrar más información sobre configurar Babel con AVA en la [receta babelrc](babelrc.md).
-
-## Usando [Enzyme](https://github.com/airbnb/enzyme)
-
-Primero veamos cómo utilizar AVA con una de las librerías de tests más populares para React: [Enzyme](https://github.com/airbnb/enzyme).
-
-Si sólo pretendes usar [renderizado superficial de componentes](https://facebook.github.io/react/docs/test-utils.html#shallow-rendering), no necesitas ninguna configuración adicional.
-
-Primero instala [los paquetes necesarios para Enzyme](https://github.com/airbnb/enzyme/#installation):
-
-```console
-$ npm install --save-dev enzyme react-addons-test-utils react-dom
-```
-
-Entonces puedes usar Enzyme directamente:
-
-```js
-import test from 'ava';
-import React from 'react';
-import { shallow } from 'enzyme';
-
-const Foo = ({children}) =>
-	<div className="Foo">
-		<span className="bar">bar</span>
-		{children}
-		<span className="bar">bar</span>
-	</div>;
-
-Foo.propTypes = {
-	children: React.PropTypes.any
-};
-
-test('tiene la clase `.Foo`', t => {
-	const wrapper = shallow(<Foo/>);
-	t.true(wrapper.hasClass('Foo'));
-});
-
-test('renderiza dos `.Bar`', t => {
-	const wrapper = shallow(<Foo/>);
-	t.is(wrapper.find('.bar').length, 2);
-});
-
-test('renderiza los hijos que se le pasen', t => {
-	const wrapper = shallow(
-		<Foo>
-			<div className="unique"/>
-		</Foo>
-	);
-	t.true(wrapper.contains(<div className="unique"/>));
-});
-```
-
-Enzyme también tiene un helper `mount` y un `render` para testear en un entorno real de navegador. Si quieres usar esos helpers, tendrás que configurar un entorno de navegador. Échale un vistazo a la [receta de cómo hacer tests en un navegador](https://github.com/avajs/ava/blob/master/docs/recipes/browser-testing.md) para ver cómo hacerlo.
-
-Para ver un ejemplo de uso de AVA junto con Enzyme configurado para tests en navegador, échale un vistazo a este [proyecto de ejemplo](https://github.com/adriantoine/ava-enzyme-demo).
-
-Éste es un ejemplo básico de cómo integrar Enzyme con AVA. Para más información sobre Enzyme para testear componentes de React, échale un vistazo a la [documentación de Enzyme](http://airbnb.io/enzyme/).
-
-## Utilizando helpers de JSX
-
-Otro enfoque para testear componentes de React es usar el paquete [`react-element-to-jsx-string`](https://github.com/algolia/react-element-to-jsx-string) para comparar árboles DOM como cadenas. [`jsx-test-helpers`](https://github.com/MoOx/jsx-test-helpers) es una buena librería para gestionar el [renderizado superficial de componentes](https://facebook.github.io/react/docs/test-utils.html#shallow-rendering) y convertir JSX en strings para testear componentes de React utilizando aseveraciones ("asserts") de AVA.
-
-```console
-$ npm install --save-dev jsx-test-helpers
-```
-
-Ejemplo de uso:
-
-```js
-import test from 'ava';
-import React from 'react';
-import { renderJSX, JSX } from 'jsx-test-helpers';
-
-const Foo = ({children}) =>
-	<div className="Foo">
-		<span className="bar">bar</span>
-		{children}
-		<span className="bar">bar</span>
-	</div>;
-
-Foo.propTypes = {
-	children: React.PropTypes.any
-};
-
-test('renderiza correctamente el markup', t => {
-	const actual = renderJSX(<Foo/>);
-	const expected = JSX(
-		<div className="Foo">
-			<span className="bar">bar</span>
-			<span className="bar">bar</span>
-		</div>
-	);
-	t.is(actual, expected);
-});
-
-test('renderiza los hijos que se le pasen', t => {
-	const actual = renderJSX(
-		<Foo>
-			<div className="unique"/>
-		</Foo>
-	);
-	const expected = JSX(
-		<div className="Foo">
-			<span className="bar">bar</span>
-			<div className="unique"/>
-			<span className="bar">bar</span>
-		</div>
-	);
-	t.is(actual, expected);
-});
-```
-
-Nota el uso de variables como `actual` y `expected` porque [`power-assert` no gestiona el JSX correctamente](https://github.com/power-assert-js/power-assert/issues/34).
-
-Éste es un ejemplo básico de cómo usar `jsx-test-helpers` con AVA. Para un uso más avanzado de esta librería, échale un vistazo a [este fichero de tests con anotaciones](https://github.com/MoOx/jsx-test-helpers/blob/master/src/__tests__/index.js).
-
-[Este proyecto de ejemplo](https://github.com/MoOx/jsx-test-helpers) muestra un uso básico y con una configuración mínima de AVA con `jsx-test-helpers`.
-
-## Utilizando otras librerías de aseveración
-
-En AVA, puedes usar cualquier librería de aseveraciones, y ya hay unas cuentas ahí fuera para testear componentes de React. He aquí una lista de librerías de aseveraciones que combinan bien con AVA:
-
-- [`expect-jsx`](https://github.com/algolia/expect-jsx) ([Ejemplo](https://github.com/avajs/ava/issues/186#issuecomment-161317068))
-- [`unexpected-react`](https://github.com/bruderstein/unexpected-react) ([Proyecto de muestra con un ejemplo de output](https://github.com/adriantoine/ava-unexpected-react-demo))
+___
+**Nota del traductor**
+
+Esta es la traducción del archivo [react.md](https://github.com/avajs/ava/blob/master/react.md). Aquí hay un [enlace](https://github.com/avajs/ava/compare/8e2f3dca177a4283ad882596d3c1425cabb998ef...master#diff-60cce07a584082115d230f2e3d571ad6) a las diferencias con la rama master de AVA (Si al hacer click en el enlace no se encuentran modificaciones en el archivo `react.md`, será por que la traducción está actualizada).
+___
+# Testeando componentes de React
+
+Traducciones: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/react.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/react.md)
+
+## Configurando Babel
+
+El primer paso es configurar Babel para transiplar el código JSX de los tests añadiendo una sección para ava en tu `package.json`:
+
+```json
+{
+  "ava": {
+    "require": ["babel-register"],
+    "babel": "inherit"
+  },
+  "babel": {
+    "presets": ["react"]
+  }
+}
+```
+
+Puedes encontrar más información sobre configurar Babel con AVA en la [receta babelrc](babelrc.md).
+
+## Usando [Enzyme](https://github.com/airbnb/enzyme)
+
+Primero veamos cómo utilizar AVA con una de las librerías de tests más populares para React: [Enzyme](https://github.com/airbnb/enzyme).
+
+Si sólo pretendes usar [renderizado superficial de componentes](https://facebook.github.io/react/docs/test-utils.html#shallow-rendering), no necesitas ninguna configuración adicional.
+
+Primero instala [los paquetes necesarios para Enzyme](https://github.com/airbnb/enzyme/#installation):
+
+```console
+$ npm install --save-dev enzyme react-addons-test-utils react-dom
+```
+
+Entonces puedes usar Enzyme directamente:
+
+```js
+import test from 'ava';
+import React from 'react';
+import { shallow } from 'enzyme';
+
+const Foo = ({children}) =>
+	<div className="Foo">
+		<span className="bar">bar</span>
+		{children}
+		<span className="bar">bar</span>
+	</div>;
+
+Foo.propTypes = {
+	children: React.PropTypes.any
+};
+
+test('tiene la clase `.Foo`', t => {
+	const wrapper = shallow(<Foo/>);
+	t.true(wrapper.hasClass('Foo'));
+});
+
+test('renderiza dos `.Bar`', t => {
+	const wrapper = shallow(<Foo/>);
+	t.is(wrapper.find('.bar').length, 2);
+});
+
+test('renderiza los hijos que se le pasen', t => {
+	const wrapper = shallow(
+		<Foo>
+			<div className="unique"/>
+		</Foo>
+	);
+	t.true(wrapper.contains(<div className="unique"/>));
+});
+```
+
+Enzyme también tiene un helper `mount` y un `render` para testear en un entorno real de navegador. Si quieres usar esos helpers, tendrás que configurar un entorno de navegador. Échale un vistazo a la [receta de cómo hacer tests en un navegador](https://github.com/avajs/ava/blob/master/docs/recipes/browser-testing.md) para ver cómo hacerlo.
+
+Para ver un ejemplo de uso de AVA junto con Enzyme configurado para tests en navegador, échale un vistazo a este [proyecto de ejemplo](https://github.com/adriantoine/ava-enzyme-demo).
+
+Éste es un ejemplo básico de cómo integrar Enzyme con AVA. Para más información sobre Enzyme para testear componentes de React, échale un vistazo a la [documentación de Enzyme](http://airbnb.io/enzyme/).
+
+## Utilizando helpers de JSX
+
+Otro enfoque para testear componentes de React es usar el paquete [`react-element-to-jsx-string`](https://github.com/algolia/react-element-to-jsx-string) para comparar árboles DOM como cadenas. [`jsx-test-helpers`](https://github.com/MoOx/jsx-test-helpers) es una buena librería para gestionar el [renderizado superficial de componentes](https://facebook.github.io/react/docs/test-utils.html#shallow-rendering) y convertir JSX en strings para testear componentes de React utilizando aseveraciones ("asserts") de AVA.
+
+```console
+$ npm install --save-dev jsx-test-helpers
+```
+
+Ejemplo de uso:
+
+```js
+import test from 'ava';
+import React from 'react';
+import { renderJSX, JSX } from 'jsx-test-helpers';
+
+const Foo = ({children}) =>
+	<div className="Foo">
+		<span className="bar">bar</span>
+		{children}
+		<span className="bar">bar</span>
+	</div>;
+
+Foo.propTypes = {
+	children: React.PropTypes.any
+};
+
+test('renderiza correctamente el markup', t => {
+	const actual = renderJSX(<Foo/>);
+	const expected = JSX(
+		<div className="Foo">
+			<span className="bar">bar</span>
+			<span className="bar">bar</span>
+		</div>
+	);
+	t.is(actual, expected);
+});
+
+test('renderiza los hijos que se le pasen', t => {
+	const actual = renderJSX(
+		<Foo>
+			<div className="unique"/>
+		</Foo>
+	);
+	const expected = JSX(
+		<div className="Foo">
+			<span className="bar">bar</span>
+			<div className="unique"/>
+			<span className="bar">bar</span>
+		</div>
+	);
+	t.is(actual, expected);
+});
+```
+
+Nota el uso de variables como `actual` y `expected` porque [`power-assert` no gestiona el JSX correctamente](https://github.com/power-assert-js/power-assert/issues/34).
+
+Éste es un ejemplo básico de cómo usar `jsx-test-helpers` con AVA. Para un uso más avanzado de esta librería, échale un vistazo a [este fichero de tests con anotaciones](https://github.com/MoOx/jsx-test-helpers/blob/master/src/__tests__/index.js).
+
+[Este proyecto de ejemplo](https://github.com/MoOx/jsx-test-helpers) muestra un uso básico y con una configuración mínima de AVA con `jsx-test-helpers`.
+
+## Utilizando otras librerías de aseveración
+
+En AVA, puedes usar cualquier librería de aseveraciones, y ya hay unas cuentas ahí fuera para testear componentes de React. He aquí una lista de librerías de aseveraciones que combinan bien con AVA:
+
+- [`expect-jsx`](https://github.com/algolia/expect-jsx) ([Ejemplo](https://github.com/avajs/ava/issues/186#issuecomment-161317068))
+- [`unexpected-react`](https://github.com/bruderstein/unexpected-react) ([Proyecto de muestra con un ejemplo de output](https://github.com/adriantoine/ava-unexpected-react-demo))
diff --git a/it_IT/code-of-conduct.md b/it_IT/code-of-conduct.md
index 7ae803bf..646505e1 100644
--- a/it_IT/code-of-conduct.md
+++ b/it_IT/code-of-conduct.md
@@ -1,31 +1,53 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [code-of-conduct.md](https://github.com/avajs/ava/blob/master/code-of-conduct.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `code-of-conduct.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [code-of-conduct.md](https://github.com/sindresorhus/ava/blob/master/code-of-conduct.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-d3030a18b089fdb1fbfabf6e75e4aef0) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `code-of-conduct.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
-# Codice di Condotta per il Collaboratore
+# Accordo di Condotta per il Collaboratore
 
-Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/code-of-conduct.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/code-of-conduct.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/code-of-conduct.md), [Portugués](https://github.com/avajs/ava-docs/blob/master/pt_BR/code-of-conduct.md)
+Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/code-of-conduct.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/code-of-conduct.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/code-of-conduct.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/code-of-conduct.md), [Português](https://github.com/avajs/ava-docs/blob/master/pt_BR/code-of-conduct.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/code-of-conduct.md), [简体中文](https://github.com/avajs/ava-docs/blob/master/zh_CN/code-of-conduct.md)
 
-Come collaboratore e amministratore di questo progetto, e nell'interesse di incoraggiare una comunità aperta e accogliente, noi promettiamo di rispettare tutte le persone che collaborano mediante la notifica di errori, creando nuove funzionalità, aggiornando la documentazione, inviando pull request o correzioni, e altre attività.
+## La nostra promessa
 
-Noi promettiamo di rendere la parteipazione in questo progetto un'esperienza senza offese, indipendentemente dal livello di esperienza, genere, identità o espressione di genere, orientamento sessuale, disabilità, apparenza fisica, dimensione corporea, razza, etnia, età, religione o nazionalità.
+Nell'interesse di incoraggiare un ambiente aperto e accogliente, come contributori e amministratori promettiamo di rendere la partecipazione al nostro progetto e alla nostra comunità un'esperienza senza alcun tipo di offesa o molestia per chiunque, senza limiti di età, corporatura, disabilità, etnicità, identità di genere e espressione, livello di esperienza, nazionalità, apparenza della propria persona, razza, religione o orientamento sessuale e identità.
+
+## I nostri standard
+
+Questi sono alcuni esempi di comportamento che inducono a creare un ambiente positivo:
+
+* Uso di linguaggio che includa tutti ed accogliente
+* Essere rispettosi dei diversi punti di vista ed esperienze
+* Accettare con gratitudine criticismo costruttivo
+* Dare attenzione a ciò che è importante per la comunità
+* Mostrare empatia verso altri membri della comunità
 
 Esempi di comportamento non tollerato dai partecipanti include:
 
-* L'uso di linguaggio o immagini a sfondo sessuale
-* Attacchi personali
-* Commenti irrispettosi o con insulti (*trolling*)
+* L'uso di linguaggio o immagini a sfondo sessuale e advances o commenti non graditi di natura sessuale
+* Commenti irrispettosi, insulti (*trolling*) ed attacchi personali o politici
 * Pubblicazione di informazioni private di altre persone, come indirizzi elettronici o finisci, senza consenso esplicito
-* Altra condotta non etica o non professionale
+* Altra condotta che potrebbe essere considerata non etica o non professionale
+
+## Le nostre responsabilità
+
+Gli amministratori del progetto sono responsabili di rendere chiari gli standard di comportamento accettabile e di prendere tutte quelle azioni appropriate, eque e correttive in risposta ad ogni evento di comportamento non accettabile.
 
 Gli amministratori del progetto hanno il diritto e la responsabilità di rimuovere, modificare o rifutare commenti, commit, codice, modifiche del wiki, issues, e altri tipi di collaborazioni che non sono conformi a questo Codice di Condotta, o bannare temporaneamente o permanentemente ciascun collaboratore il comportamento sia inappropriato, minacciatorio, offensivo o pregiudiziale.
 
-Adottando questo Codice di Condotta, gli amministratori del progetto si dedicano ad una giusta e consistente applicazione di questi principi in ogni aspetto dell'amministrazione del progetto. Gli amministratori del progetto che non seguano o assicurino il Codice di Condotta possono essere permanentemente rimossi dal gruppo amministrativo.
+## Dove si applica questo codice
+
+Questo Codice di Condotta si applica sia all'interno dello spazio del progetto che in luoghi pubblici dove un individuo che rappresenta il progetto o la sua comunità che utilizzi un indirizzo di email ufficiale del progetto, scrivendo su di un account ufficiale del progetto o agendo come rappresentante ufficiale ad un evento online o offline. La rappresentanza del progetto potrà essere definita in seguito e resa chiara dai amministratori del progetto.
 
-Questo Codice di Condotta si applica sia all'interno dello spazio del progetto che in luoghi pubblici dove un individuo rappresenta il progetto o la sua comunità.
+## Applicazione del presente codice
 
 Istanze di abuso, intimidazione o altro tipi di comportamento non tollerato può essere segnalato contattando l'amministratore del progetto [sindresorhus@gmail.com](mailto:sindresorhus@gmail.com) . Tutte le lamentele saranno controllate ed investigate ed il risultato sarà rilasciato nei modi e forme appropriate alla circostanza. Gli amministratori sono obbligati a mantenere la confidenzialità dell'individuo che ha riportato l'incidente.
+Ulteriori dettagli dell'applicazione specifica della disciplina presa potrà essere pubblicata in modo separato.
+
+Gli amministratori che non seguano o applichino il Codice di Condotta in buona fede potranno avere ripercussioni temporanee come determinato dagli altri membri dell'amministrazione del progetto.
+
+## Attribuzione
 
+Questo Codice di Condotta è un adattamento del [Contributor Covenant][homepage], versione 1.4, disponible su [http://contributor-covenant.org/version/1/4][version].
 
-Questo Codice di Condotta è un adattamento del [Contributor Covenant](http://contributor-covenant.org), versione 1.3.0, disponible su [http://contributor-covenant.org/version/1/3/0/it/](http://contributor-covenant.org/version/1/3/0/it/).
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/it_IT/contributing.md b/it_IT/contributing.md
index 10679ed0..d424db36 100644
--- a/it_IT/contributing.md
+++ b/it_IT/contributing.md
@@ -1,7 +1,7 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [contributing.md](https://github.com/avajs/ava/blob/master/contributing.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `contributing.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [contributing.md](https://github.com/avajs/ava/blob/master/contributing.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `contributing.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # Contribuire ad AVA
 
@@ -72,3 +72,5 @@ Abbiamo una [chat](https://gitter.im/avajs/ava). Visita e dai un'occhiata, parla
 - Potremmo chiederti di fare dei cambiamenti alla tua pull request. Non c'è bisogno di aprire una nuova pull request, semplicemente [aggiorna quella già aperta](https://github.com/RichardLitt/docs/blob/master/amending-a-commit-guide.md).
 
 Attenzione: quando fai modifiche al codice, ricorda che il mantra di AVA (preso da Python) è avere preferibilmente un unico modo di fare qualcosa. Ad esempio, una pull request per aggiungere un alias per una parte dell'API ([come questo](https://github.com/avajs/ava/pull/663))) sarà molto probabilmente rifiutata se non introduce qualche ulteriore beneficio.
+
+*Stai cercando un progetto open source a cui contribuire? Eccolo! AVA è un progetto con una comunità accogliente su Internet. Dai un'occhiata al blog post ["Making your first contribution"](https://medium.com/@vadimdemedes/making-your-first-contribution-de6576ddb190) per avere un'idea di come iniziare e contribuire ad AVA!*
diff --git a/it_IT/docs/common-pitfalls.md b/it_IT/docs/common-pitfalls.md
new file mode 100644
index 00000000..05221cf6
--- /dev/null
+++ b/it_IT/docs/common-pitfalls.md
@@ -0,0 +1,85 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [common-pitfalls.md](https://github.com/avajs/ava/blob/master/docs/common-pitfalls.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-7eb46230db3eba276054b9adbc6c82ca) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `common-pitfalls.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Errori comuni
+
+Traduzioni: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/common-pitfalls.md),
+[Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/common-pitfalls.md)
+
+## Plugin ESLint
+
+Se usi [ESLint](http://eslint.org/), puoi installare [eslint-plugin-ava](https://github.com/avajs/eslint-plugin-ava). Ti aiuterà ad usare correttamente AVA e ad evitare alcuni errori comuni.
+
+## AVA in Docker
+
+Se usi AVA in Docker nel tuo CI, hai bisogno di impostare le variabili d'ambiente correttamente. Nello specifico aggiungi `-e CI=true` nel comando `docker exec`. Per maggiori informazioni guarda [#751](https://github.com/avajs/ava/issues/751).
+
+AVA usa [is-ci](https://github.com/watson/is-ci) per capise se è eseguito in un ambiente di CI o no, basandosi su [questi variabili](https://github.com/watson/is-ci/blob/master/index.js).
+
+## AVA ed il limite di client connessi
+
+Potresti utilizzare un servizio che permette un numero limitato di connessioni concorrenti. Ad esempio, molte aziende con prodotti Database-as-a-service offrono piani con un numero limitato di client connessi nello stesso momento. AVA può superare questi limiti poichè esegue processi multiple, ma questi servizi dovrebbero inviare un errore o incodare la richiesta in questi casi. Se il tuo servizio non si comporta in questo modo, i test potrebbero rimanere in sospeso.
+
+Usa il flag `concurrency` per limitare il numero di processi da eseguire in AVA. Per esempio, se il piano del tuo servizio ti permette di eseguire 5 client alla volta, dovresti configurare AVA con `concurrency=5` o meno.
+
+## Operazioni Asincrone
+
+Talvolta test con operazioni asincrone potrebbero rimanere appesi e non terminare. Se utilizzi Promises per le operazioni asincrone, ricorda di restituire la Promise finale:
+
+
+```js
+test(t => {
+	return fetch().then(data => {
+		t.is(data, 'foo');
+	});
+});
+```
+
+Ancor meglio, usa `async` / `await`:
+
+```js
+test(async t => {
+	const data = await fetch();
+	t.is(data, 'foo');
+});
+```
+
+Se invece stai usando le callbacks, usa [`test.cb`](https://github.com/avajs/ava#callback-support):
+
+```js
+test.cb(t => {
+	fetch((err, data) => {
+		t.is(data, 'foo');
+		t.end();
+	});
+});
+```
+
+Come ultima alternativa, trasforma la callback in Promise con qualcosa come [`pify`](https://github.com/sindresorhus/pify):
+
+```js
+test(async t => {
+	const data = await pify(fetch)();
+	t.is(data, 'foo');
+});
+```
+
+### Attribuzione di errori non catturati nei test
+
+AVA [non può tracciare errori non catturati](https://github.com/avajs/ava/issues/214) e associarli al giusto test che l'ha lanciato. Spesso utilizzando callback nei test può indurre a errori non catturati che possono essere difficili da risolvere. Considera il processo di "promisify" e l'utilizzo di `async` / `await`, come nell'esempio sopra. Questo permette ad AVA di catturare gli errori e attribuirle correttamente al test che l'ha lanciato.
+
+### Perchè i messaggi delle asserzioni avanzate non vengono mostrati?
+
+Controlla che il primo parametro passato al tuo test sia chiamato `t`. Questo è un requisito di [`power-assert`](https://github.com/power-assert-js/power-assert), cioè la libreria usata per i messaggi avanzati.
+
+```js
+test(t => {
+	t.is(1, 1);
+});
+```
+
+---
+
+Il problema che hai non è in questa lista? Invia una pull request o commenta in [questa issue](https://github.com/avajs/ava/issues/404). 
diff --git a/it_IT/docs/recipes/babelrc.md b/it_IT/docs/recipes/babelrc.md
index e9a54644..42462cae 100644
--- a/it_IT/docs/recipes/babelrc.md
+++ b/it_IT/docs/recipes/babelrc.md
@@ -1,7 +1,7 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [babelrc.md](https://github.com/avajs/ava/blob/master/docs/recipes/babelrc.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `babelrc.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [babelrc.md](https://github.com/avajs/ava/blob/master/docs/recipes/babelrc.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `babelrc.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # Configurare Babel
 
@@ -19,20 +19,39 @@ Ci sono più opzioni per configurare il mdoo in cui AVA transpila i tuoi test co
 
 ## Impostazione predefinita per la transpilazione in AVA
 
-AVA transpila i tuoi file di test (e sono questi) utilizzando le impostazioni Babel  [`es2015`](http://babeljs.io/docs/plugins/preset-es2015/) e [`stage-2`](http://babeljs.io/docs/plugins/preset-stage-2/). Questa è l'impostazione migliore per piccoli moduli in cui tu non voglia transpilare i tuoi sorgenti prima di pubblicare su `npm`.
+AVA ti permette di usare nuove funzionalità JavaScript, come le [async functions](https://github.com/avajs/ava#async-function-support). Per usare queste nuove funzioni su vecchie versioni di Node.js AVA transpila i test ed i file helper con l'impostazione Babel [`@ava/stage-4`](https://github.com/avajs/babel-preset-stage-4). Questo è molto utile per progetti dove non si utilizza Babel per i file sorgenti, ma si vogliono usare le nuove funzionalità JavaScript per i test.
 
 ## Personalizzare come AVA transpila i tuoi test
 
 Puoi sovrascrivere la configurazione Babel predefinita in AVA da usare per transpilare i test nel `package.json`. Ad esempio, la configurazione seguente aggiunge il plugin Babel `rewire` ed utilizza l'impostazione [`stage-3`](http://babeljs.io/docs/plugins/preset-stage-3/)(che è un sottoinsieme di [`stage-2`](http://babeljs.io/docs/plugins/preset-stage-2/)).
 
+Puoi sovrascrivere la configurazione predefinita di Babel che AVA utilizza per la traspilazione dei test nel `package.json`. Per esempio, la configurazione sotto aggiunge il plugin Babel `rewire`, e aggiunge l'impostazione [`stage-3`](http://babeljs.io/docs/plugins/preset-stage-3/) a Babel.
+
+You can override the default Babel configuration AVA uses for test transpilation in `package.json`. For example, the configuration below adds the Babel `rewire` plugin, and adds the Babel [`stage-3`](http://babeljs.io/docs/plugins/preset-stage-3/) preset.
+
 ```json
 {
-  "ava": {
-    "babel": {
-      "plugins": ["rewire"],
-      "presets": ["es2015", "stage-3"]
+    "ava": {
+        "babel": {
+            "plugins": ["rewire"],
+            "presets": ["@ava/stage-4", "stage-3"]
+        }
     }
-  }
+}
+```
+
+## Usare Polyfills per Babel
+
+AVA ti permette di scrivere i test con la nuova sintassi JavaScript, anche su versioni vecchie di Node.js che non lo supportano nativamente. Questo non aggiunge o modifica il tuo ambiente corrente. Per esempio usando AVA non si aggiungono funzionalità come `Array.prototype.includes()` ad un ambiente Node.js 4.
+Caricando il  [modulo Babel Polyfill](https://babeljs.io/docs/usage/polyfill/) puoi aggiungere queste funzionalità.
+Considera che questo modulo modificherà l'ambiente che stai utilizzando, cambiando potenzialmente il comportamento del tuo software. Puoi abilitare `babel-polyfill` aggiungendolo all'opzione `require` di AVA:
+```json
+{
+	"ava": {
+		"require": [
+			"babel-polyfill"
+		]
+	}
 }
 ```
 
@@ -48,7 +67,7 @@ Per transpilare i tuoi file sorgente, avrai bisogno di definire una [`configuraz
     "require": ["babel-register"]
   },
   "babel": {
-    "presets": ["es2015"]
+    "presets": ["@ava/stage-4"]
   }
 }
 ```
@@ -68,12 +87,14 @@ Utilizzando l'impostazione `"inherit"` i tuoi test verranno transpilati allo ste
     "babel": "inherit"
   },
   "babel": {
-    "presets": ["es2015", "react"]
+    "presets": ["@ava/stage-4", "react"]
   }
 }
 ```
 
-Nell'esempio sopra, sia i file di test che sorgente saranno transpilati utilizzando le impostazioni [`es2015`](http://babeljs.io/docs/plugins/preset-es2015/) e [`react`](http://babeljs.io/docs/plugins/preset-react/).
+Nell'esempio sopra, sia i file di test che sorgente saranno transpilati utilizzando le impostazioni [`@ava/stage-4`](https://github.com/avajs/babel-preset-stage-4) e [`react`](http://babeljs.io/docs/plugins/preset-react/).
+
+AVA controllerà solamente l'esistenza del file `.babelrc` nella stessa cartella del file `package.json`. Se questo file non venisse trovato allora si assume che la configurazione Babel è inclusa nel file `package.json`.
 
 ## Estendere la configurazione per la transpilazione dei sorgenti
 
@@ -92,12 +113,14 @@ Quando configuri le impostazioni Babel per i tuoi test, puoi impostare l'opzione
     }
   },
   "babel": {
-    "presets": ["es2015", "react"]
+    "presets": ["@ava/stage-4", "react"]
   }
 }
 ```
 
-Nell'esempio sopra, *i file sorgente* sono compilati utilizzando le impostazioni [`es2015`](http://babeljs.io/docs/plugins/preset-es2015/) e [`react`](http://babeljs.io/docs/plugins/preset-react/), *i file di test* utilizzano i suddetti plugin, con l'aggiunta de plugin `custom` specificato.
+Nell'esempio sopra, *i file sorgente* sono compilati utilizzando le impostazioni [`@ava/stage-4`](https://github.com/avajs/babel-preset-stage-4) e [`react`](http://babeljs.io/docs/plugins/preset-react/), *i file di test* utilizzano i suddetti plugin, con l'aggiunta de plugin `custom` specificato.
+
+AVA controllerà solamente l'esistenza del file `.babelrc` nella stessa cartella del file `package.json`. Se questo file non venisse trovato allora si assume che la configurazione Babel è inclusa nel file `package.json`.
 
 ## Estendere un file di configurazione alternativo
 
@@ -118,14 +141,4 @@ Se, per qualche motivo, la tua configurazione Babel non si trova in una dei file
 }
 ```
 
-L'esempio sopra utilizza `babel-test-config.json` come configurazione per il transpiling dei *file sorgente* e come configurazione di base per i *file di test*. Per i *file di test* la configurazione verrà comunque estesa con i plugin e le impostazioni specificati.
-
-## Note
-
-AVA aggiunge *sempre* qualche plugin Babel personalizzati quando transpila i tuoi plugin. Questi plugin personalizzati servono per diverse funzioni:
-
-* Abilitare il supporto per i `power-assert`
-* Riscrivere i path per i require delle dipendenze interne di AVA, tipo `babel-runtime` (importante se stai ancora usando `npm@2`)
-* [`ava-throws-helper`](https://github.com/jamestalmage/babel-plugin-ava-throws-helper) permette ad AVA di [individuare e notificare](https://github.com/avajs/ava/pull/742) usi impropri di asserzioni `t.throws`.
-* Generare metadati sui test per determinare quali file devono essere eseguiti prima di altri (*in futuro*)
-* Analisi statica delle dipendenza per la precompilazione (*in futuro*).
+L'esempio sopra utilizza `babel-test-config.json` come configurazione per il transpiling dei *file sorgente* e come configurazione di base per i *file di test*. Per i *file di test* la configurazione verrà comunque estesa con i plugin e le impostazioni specificati.
\ No newline at end of file
diff --git a/it_IT/docs/recipes/browser-testing.md b/it_IT/docs/recipes/browser-testing.md
index 47a5b96f..76948876 100644
--- a/it_IT/docs/recipes/browser-testing.md
+++ b/it_IT/docs/recipes/browser-testing.md
@@ -1,37 +1,47 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [browser-testing.md](https://github.com/avajs/ava/blob/master/docs/recipes/browser-testing.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `browser-testing.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [browser-testing.md](https://github.com/avajs/ava/blob/master/docs/recipes/browser-testing.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `browser-testing.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # Preparare AVA per il Browser testing
 
 Traduzioni: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/browser-testing.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/docs/recipes/browser-testing.md)
 
-Con AVA non è possibile eseguire test all'interno di un browser [ancora](https://github.com/avajs/ava/issues/24). Alcune librerie richiedono alcune variabili globali specifiche del browser (`window`, `document`, `navigator`, etc).
+Con AVA non è possibile eseguire test all'interno di un browser [per ora](https://github.com/avajs/ava/issues/24). Alcune librerie richiedono alcune variabili globali specifiche del browser (`window`, `document`, `navigator`, etc).
 React ne è un esempio, o almeno se vuoi utilizzare ReactDOM.render e simulare gli eventi con ReactTestUtils.
 
 Questa ricetta funziona per ogni libreria che ha bisogno di un finto ambiente browser.
 
-## Istallare jsdom
+## Installare browser-env
 
-Istallare [jsdom](https://github.com/tmpvar/jsdom).
+> **️❗️ Nota importante**
+>
+>`browser-env` aggiunge proprietà dal namespace window al namespace globale in Node.js. Questo è un qualcosa esplicitamente [non raccomandato](https://github.com/tmpvar/jsdom/wiki/Don't-stuff-jsdom-globals-onto-the-Node-global) da `jsdom`. Leggi la pagina di wiki nel link e sii sicuro di comprendere le possibili problematiche. Se non hai molte dipendenze che potrebbero richiedere un ambiente browser allora [`window`](https://github.com/lukechilds/window#universal-testing-pattern) potrebbe essere una soluzione alternativa migliore.
 
-> Un'implementazione JavaScript degli standard WHATWG DOM  e HTML, da usare con node.js
+Installare [browser-env](https://github.com/lukechilds/browser-env).
+
+> Simula un ambiente browser con l'ausilio di jsdom.
 
 ```
-$ npm install --save-dev jsdom
+$ npm install --save-dev browser-env
 ```
 
-## Configurare jsdom
+## Configurare browser-env
 
 Creare un file helper e salvarlo nella cartella `test/helper`. Questo assicura che AVA non lo consideri un file di test.
 
 `test/helpers/setup-browser-env.js`:
 
 ```js
-global.document = require('jsdom').jsdom('<body></body>');
-global.window = document.defaultView;
-global.navigator = window.navigator;
+import browserEnv from 'browser-env';
+browserEnv();
+```
+
+`browser-env` aggiungerà tutte le variabili del browser globali alla variabile globale in Node.js, imitando un ambiente browser completo. Questo dovrebbe essere sufficientemente compatibile con molte librerie front-end, anche se, non è in genere consigliata la creazione di molte variabili globali senza reale necessità. Se conosci esattamente quali variabili browser globali hai bisogno, puoi passare un Array con la lista.
+
+```js
+import browserEnv from 'browser-env';
+browserEnv(['window', 'document', 'navigator']);
 ```
 
 ## Configura i test per l'utilizzo di jsdom
@@ -52,7 +62,21 @@ Configura AVA per richiedere con `require` il file helper per ogni file di test.
 
 ## Tutto fatto!
 
-Scrivi i tuoi test e usa il finto oggetto window.
+Ora puoi scrivere i tuoi test e usare un (finto) ambiente browser.
+
+`test/my.dom.test.js`:
+
+```js
+import test from 'ava';
+
+test('Insert to DOM', t => {
+	const div = document.createElement('div');
+	document.body.appendChild(div);
+
+	t.is(document.querySelector('div'), div);
+});
+```
+
 
 `test/my.react.test.js`:
 
diff --git a/it_IT/docs/recipes/code-coverage.md b/it_IT/docs/recipes/code-coverage.md
index 33ad9678..9cd4a5e4 100644
--- a/it_IT/docs/recipes/code-coverage.md
+++ b/it_IT/docs/recipes/code-coverage.md
@@ -1,7 +1,7 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [code-coverage.md](https://github.com/avajs/ava/blob/master/docs/recipes/code-coverage.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `code-coverage.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [code-coverage.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/code-coverage.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-d3030a18b089fdb1fbfabf6e75e4aef0) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `code-coverage.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # Code coverage
 
@@ -104,8 +104,6 @@ Per utilizzare l'hook `require` di Babel, aggiungi `babel-core/register` nella s
 ```
 
 
-*Nota*: puoi anche impostare l'hook `require` dalla linea di comando: `ava --require=babel-core/register`. Ciononostante, la configurazione nel `package.json` permette di evitare di dover scrivere quel parametro ogni volta.
-
 ### Combinando tutto
 
 Combinando tutti i passaggi precedenti, il tuo `package.json` completo dovrebbe assomigliare al seguente:
diff --git a/it_IT/docs/recipes/debugging-with-chrome-devtools.md b/it_IT/docs/recipes/debugging-with-chrome-devtools.md
new file mode 100644
index 00000000..7afe8fd0
--- /dev/null
+++ b/it_IT/docs/recipes/debugging-with-chrome-devtools.md
@@ -0,0 +1,20 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [debugging-with-chrome-devtools.md](https://github.com/avajs/ava/blob/master/docs/recipes/debugging-with-chrome-devtools.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-7621c4f96f622506986f9cf7a125d6a1) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `debugging=with-chrome-devtools.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Fare debugging con i Chrome DevTools
+
+Traduzioni:
+[Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/debugging-with-chrome-devtools.md),
+[Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-chrome-devtools.md)
+
+Usa [inspect-process](https://github.com/jaridmargolin/inspect-process) per lanciare una sessione di debugging con i Chrome DevTools.
+
+```console
+$ npm install --global inspect-process
+```
+
+```console
+$ inspect node_modules/ava/profile.js some/test/file.js
+```
diff --git a/it_IT/docs/recipes/debugging-with-vscode.md b/it_IT/docs/recipes/debugging-with-vscode.md
new file mode 100644
index 00000000..939dda28
--- /dev/null
+++ b/it_IT/docs/recipes/debugging-with-vscode.md
@@ -0,0 +1,41 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [debugging-with-vscode.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/debugging-with-vscode.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-a3927068f3a0ffbbdf1b02fbd401b146) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `debugging-with-vscode.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Fare debugging dei test con Visual Studio Code
+
+Translations: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/debugging-with-vscode.md)
+[Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-vscode.md)
+
+## Setup
+
+Sulla barra a lato di VSCode clicca su `Debug`.
+
+Aggiungi una nuova configurazione cliccando sul campo a fianco del tasto verde `Debug`, poi clicca su `Add configuration`. Si aprirà un file `launch.json` con tutte le impostazioni per il debug.
+
+Aggiungi il seguente all'oggetto `configurations`:
+
+```json
+{
+	"type": "node",
+	"request": "launch",
+	"name": "Avvia AVA test",
+	"program": "${workspaceRoot}/node_modules/ava/profile.js",
+	"args": [
+	  "${file}"
+	]
+}
+```
+
+Dopo aver aggiunto la configurazione salva il file.
+
+## Debug
+
+> **Nota:** Il file su cui vuoi fare il debug deve essere aperto e attivo in VSCode
+
+> **Nota:** I breakpoint in VSCode possono non funzionare correttamente a volte (in particolare quando si tratta di codice async). L'istruzione `debugger;` funziona sempre correttamente.
+
+Aggiungi il breakpoint nel codice **o** aggiungere l'istruzione `debugger;` nel punto in cui si vuole fermare l'esecuzione.
+
+Clicca il tasto verde `Debug` accanto alla lista delle configurazioni, in alto a sinistra del pannello `Debug` in VSCode. Una volta che l'esecuzione si fermerà al punto in cui si è impostato il breakpoint sarà possibile guardare i valori delle variabili ed eseguire il codice riga per riga.
\ No newline at end of file
diff --git a/it_IT/docs/recipes/debugging-with-webstorm.md b/it_IT/docs/recipes/debugging-with-webstorm.md
new file mode 100644
index 00000000..cd2d7d61
--- /dev/null
+++ b/it_IT/docs/recipes/debugging-with-webstorm.md
@@ -0,0 +1,59 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [debugging-with-webstorm.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/debugging-with-webstorm.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-1fb9cdb432e04d416229256c338f1a06) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `debugging-with-webstorm.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Fare debugging con WebStorm
+
+Traduzioni:
+[Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/debugging-with-webstorm.md),
+[Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-webstorm.md)
+
+Dalla versione 2016.2, [WebStorm](https://www.jetbrains.com/webstorm/) e altri IDE JetBrains (IntelliJ IDEA Ultimate, PHPStorm, PyCharm Professional, e RubyMine con il plugin Node.js installato) ti permettono di fare debugging dei test AVA.
+
+## Setup con Node.js
+
+Aggiungi una nuova *Configurazione Run/Debug per Node.js*: seleziona `Modifica Configurazioni...` dal menù a tendina in alto a destra, poi clicca su `+` e seleziona *Node.js*.
+
+Nel campo `Javascript file` scrivi il `path` relativo all'installazione di AVA nella cartella `node_modules`: `node_modules/.bin/ava` per macOS e Linux oppure `node_modules/.bin/ava.cmd` per Windows.
+
+Nel campo `Parametri applicazione` scrivi i `flag` CLI che vuoi usare per i file di test di cui vuoi fare il debug, ad esempio `--verbose test.js`.
+
+Salva la configurazione.
+
+## Setup con npm
+
+Esegui `ava --init` nella cartella del tuo progetto per aggiungere AVA al tuo `package.json`.
+
+Il file `package.json` sarà quindi simile al seguente:
+
+```json
+{
+	"name": "awesome-package",
+	"scripts": {
+		"test": "ava"
+	},
+	"devDependencies": {
+		"ava": "^0.20.0"
+	}
+}
+```
+
+Aggiungi una *nuova configurazione di debug per `npm`*: seleziona `Edit Configurations` dal menù a tendina in alto a destra, clicca `+` e seleziona *`npm`*.
+
+Usa i seguenti parametri di configurazione:
+
+- `package.json`: percorso per il file `package.json` del tuo progetto
+- `Command`: `test`
+
+Il tuo IDE eseguirà `npm run test` chiamando `node_modules/.bin/ava` e la configurazione da te inserita nel `package.json`.
+
+Non dimenticare di selezionare l'interprete Node.js.
+
+Salva la configurazione.
+
+## Debug
+
+Imposta i breakpoints nel codice.
+
+Clicca il bottone verde `Debug` vicino alla lista delle configurazioni in alto a destra. La *finestra di debug* comparirà ed una volta che il breakpoint verrà raggiunto, potrai ispezionare le variabile ed eseguire il codice riga per riga. Quando si fa debugging più file di testing, puoi anche saltare tra processi utilizzando il menù a tendina nel pannello *Frames*.
diff --git a/it_IT/docs/recipes/endpoint-testing.md b/it_IT/docs/recipes/endpoint-testing.md
index 7ee2a004..bd5f628c 100644
--- a/it_IT/docs/recipes/endpoint-testing.md
+++ b/it_IT/docs/recipes/endpoint-testing.md
@@ -1,13 +1,13 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [endpoint-testing.md](https://github.com/avajs/ava/blob/master/docs/recipes/endpoint-testing.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `endpoint-testing.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [endpoint-testing.md](https://github.com/avajs/ava/blob/master/docs/recipes/endpoint-testing.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `endpoint-testing.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # Test di endpoint
 
-Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/endpoint-testing.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/endpoint-testing.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/docs/recipes/endpoint-testing.md), [Português](https://github.com/avajs/ava-docs/blob/master/pt_BR/docs/recipes/endpoint-testing.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/docs/recipes/endpoint-testing.md)
+Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/endpoint-testing.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/endpoint-testing.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/endpoint-testing.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/docs/recipes/endpoint-testing.md), [Português](https://github.com/avajs/ava-docs/blob/master/pt_BR/docs/recipes/endpoint-testing.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/docs/recipes/endpoint-testing.md), [简体中文](https://github.com/avajs/ava-docs/blob/master/zh_CN/docs/recipes/endpoint-testing.md)
 
-AVA non ha un metodo nativo per il test di endpoint, ma puoi utilizzare un'altra libreria di asserzione per questo. In questo esempio utilizzeremo [`supertest-as-promised`](https://github.com/WhoopInc/supertest-as-promised).
+AVA non ha un metodo nativo per il test di endpoint, ma puoi utilizzare un'altra libreria si asserzione per questo. In questo esempio utilizzeremo [`supertest`](https://github.com/visionmedia/supertest).
 
 Poichè i test saranno eseguiti in concorrenza, è meglio creare una nuova instanza del server per ciascun file di test, poichè se utilizzassimo sempre la stessa istanza, questa potrebbe cambiare il suo stato tra un test e l'altro. Questo si può fare utilizzando `test.beforeEach` e `t.context`, o semplicemente con una funzione factory:
 
diff --git a/it_IT/docs/recipes/isolated-mongodb-integration-tests.md b/it_IT/docs/recipes/isolated-mongodb-integration-tests.md
new file mode 100644
index 00000000..098e01d0
--- /dev/null
+++ b/it_IT/docs/recipes/isolated-mongodb-integration-tests.md
@@ -0,0 +1,103 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [isolated-mongodb-integration-tests.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/isolated-mongodb-integration-tests.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-fa5b24a10aa6bb9abd440902e222e84c) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `isolated-mongodb-integration-tests.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Test di integrazione per MongoDB in isolamento
+
+Translations: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/isolated-mongodb-integration-tests.md)
+[Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/isolated-mongodb-integration-tests.md)
+
+> Configurazione di un database MongoDB per i tuoi test AVA con isolamento per singolo test file
+
+Questa guida usa [`MongoMem`](https://github.com/CImrie/mongomem), una libreria che permette di eseguire velocemente un server MongoDB temporaneo localmente. Utilizza file temporanei su disco che vengono distrutti al termine dell'esecuzione del server.
+
+## Installare il server MongoDB in-memory (MongoMem)
+
+Nella cartella principale della tua app esegui:
+
+```console
+$ npm install --save-dev mongomem
+```
+
+## Come usare MongoMem
+
+Nei tuoi file di test, importa il modulo ed esegui il server.
+
+**Assicurati di eseguire il server all'inizio del tuo file, prima di tutti i test.**
+
+```js
+import test from 'ava';
+import {MongoDBServer} from 'mongomem';
+
+test.before('start server', async t => {
+	await MongoDBServer.start();
+});
+
+test('some feature', async t => {
+	const connectionString = await MongoDBServer.getConnectionString();
+
+	// connectionString === 'mongodb://localhost:27017/3411fd12-b5d6-4860-854c-5bbdb011cb93'
+	// Usa `connectionString` per connetterti al database con qualsiasi client. Vedi sotto per l'utilizzo di Mongoose.
+});
+```
+
+## Ripulire l'ambiente
+
+Dopo aver eseguito i test ricordati di includere il metodo `test.after.always()` per ripulire il server MongoDB. Questo rimuoverà tutti i file temporanei che il server ha creato durante l'esecuzione.
+
+Questi file temporanei vengono solitamente rimossi dal sistema operativo, ma è comunque buona pratica rimuoverli manualmente.
+
+```js
+test.after.always('cleanup', t => {
+	MongoDBServer.tearDown(); // Ripulisce i file temporanei generati
+});
+```
+
+## Debugging
+
+Se il server non dovesse partire, puoi impostare l'opzione `MongoDBServer.debug = true;` prima di chiamare `MongoDBServer.start()`. Questa opzione abiliterà la stampa di eventuali errori di connessione o permessi sui file duranete l'avvio. Solitamente in fase di avvio viene verificata la disponibilità di una porta prima di avviare la connessione quindi spesso gli errori sono relativi a permessi sui file più che alla connessione.
+
+## Extra: Setup e uso di Mongoose (MongoDB ODM)
+
+[Mongoose](http://mongoosejs.com) è un robusto Object-Document-Mapper (ODM) per MongoDB. Fai riferimento alla sua documentazione per vedere come configurare inizialmente Mongoose.
+
+### Importare Mongoose
+
+```js
+// `myTestCase.test.js` - (Il tuo file di test)
+import mongoose from 'mongoose';
+```
+
+`mongoose` in questo caso è una singola istanza di Mongoose ODM ed è disponibile globalmente. Questo va bene per mantenere un singolo punto d'accesso al tuo database, ma può essere problematico per il testing isolato.
+
+Le istanze di Mongoose dovrebbero essere isolate tra i tuoi test, in questo modo l'ordine di esecuzione dei test non ha effetti sul risultato finale. Questo può essere fatto con un po' di lavoro.
+
+### Isolare istanze Mongoose
+
+Richiedere nuove istanze a Mongoose è molto facile. Come prima cosa chiama `new mongoose.Mongoose()` per ottenere una nuova istanza, poi esegui `connect` con una stringa di connessione del database ottenuta dal pacchetto `mongomem`.
+
+**Dovrai copiare manualmente i modelli dalla tua istanza globali alle nuove istanze isolate.**
+
+```js
+import mongoose from 'mongoose';
+import {MongoDBServer} from 'mongomem';
+
+test.before('start server', async t => {
+	await MongoDBServer.start();
+});
+
+test.beforeEach(async t => {
+	const db = new mongoose.Mongoose();
+	await db.connect(await MongoDBServer.getConnectionString());
+	for (const name of mongoose.modelNames()) {
+		db.model(name, mongoose.model(name).schema);
+	}
+	t.context.db = db;
+});
+
+test('my Mongoose model integration test', async t => {
+	const {db} = t.context;
+	// Addesso puoi usare un'istanza DB isolata nei tuoi test
+});
+```
\ No newline at end of file
diff --git a/it_IT/docs/recipes/jspm-systemjs.md b/it_IT/docs/recipes/jspm-systemjs.md
new file mode 100644
index 00000000..37b0fed9
--- /dev/null
+++ b/it_IT/docs/recipes/jspm-systemjs.md
@@ -0,0 +1,67 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [jspm-systemjs.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/jspm-systemjs.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-e1128fe3361ff27e14e2ebec6c6ff362) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `jspm-systemjs.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# JSPM e SystemJS per ES2015
+
+Traduzioni: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/jspm-systemjs.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/jspm-systemjs.md)
+
+Per usare AVA con JSPM si richiede l'utilizzo di un loader speciale per far funzionare correttamente l'istruzione `import` dei pacchetti JSPM. Lo scopo del loader è quello di permettere di eseguire i test senza pre-compilare il tuo progetto JSPM.
+
+## Setup
+
+Questa ricetta è stata testata unicamente con JSPM v.0.17.0-beta.22 ma dovrebbe funzionare con ogni versione di JSPM v0.17 e forse anche con le versioni v0.16.
+
+### Babel
+
+Configura il file `.babelrc` per eseguire AVA se non l'hai ancora fatto. Puoi avere configurazioni aggiuntive nei tui file di configurazione JSPM per sovrascrivere queste impostazioni durante la fase di assemblamento (bundling) e compilazione.
+
+```json
+{
+	"presets": ["es2015", "stage-2"]
+}
+```
+
+Puoi trovare maggiori informazioni su come configurare Babel con AVA nella ricetta [babelrc](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/babelrc.md).
+
+### Helper JSPM Loader
+
+Come prima cosa installa il [loader JSPM per AVA](https://github.com/skorlir/ava-jspm-loader) come una dipendenza dev.
+
+```
+$ npm install --save-dev ava-jspm-loader
+```
+
+Aggiorna anche la tua configurazione AVA nel `package.json` per usare il loader JSPM.
+
+```json
+{
+	"ava": {
+		"require": [
+			"babel-register",
+			"ava-jspm-loader"
+		]
+	}
+}
+```
+
+NOTA: se usi `async`/`await` nel tuo codice sorgente (non nei tuoi file di test!) avrai bisogno di installare `babel-polyfill` da `npm` e aggiungerli al tuo Array di `require`.
+
+### File test di esempio
+
+Per tutti i tuoi file nel progetto avrai bisogno di utilizzare `System.import`. Quindi se hai chiamato il tuo progetto `app` e vuoi importare il tuo file `main.js` in un file di test dovrai importare il file in queto modo `import main from 'app/main'`.
+
+```js
+import test from 'ava';
+import main from 'app/main';  // Maps to your JSPM config for "app/main.js"
+import BigNumber from 'bignumber.js';  // In jspm_packages
+
+function fn() {
+	return Promise.resolve(new BigNumber('1234567890.123456789'));
+}
+
+test('example test', async t => {
+	t.is((await fn()).toString(), '1234567890.123456789');
+});
+```
\ No newline at end of file
diff --git a/it_IT/docs/recipes/precompiling-with-webpack.md b/it_IT/docs/recipes/precompiling-with-webpack.md
new file mode 100644
index 00000000..7dbc6951
--- /dev/null
+++ b/it_IT/docs/recipes/precompiling-with-webpack.md
@@ -0,0 +1,276 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [precompiling-with-webpack.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/precompiling-with-webpack.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-b4c25a4a1412e9204ac923133f67814f) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `precompiling-with-webpack.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+## Pre-compila i file sorgente con webpack
+
+Translations: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/precompiling-with-webpack.md),
+ [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/precompiling-with-webpack.md).
+
+Il file [readme](https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md#usare-il-transpiler-per-i-moduli-importati) dice che sia possibile transpilare i moduli importati come alternativa alla compilazione a runtime, ma non spiega come farlo. Questa ricetta spiega diversi approcci per uware webpack v2. Vengono discussi diversi approcci al problema in quanto ciascun approccio ha i suoi pro ed i suoi contro. Dovrai scegliere l'approccio che meglio di presta al tuo caso. Per maggior informazioni vedi la discussione originale sul problema [qui](https://github.com/avajs/ava/pull/1385).
+
+- [File di test singolo](#file-di-test-singolo)
+
+- [File di test multipli](#file-di-test-multipli)
+
+### File di test singolo
+
+Questo è il caso base, cioè il più semplice. Potresti aver bisogno di questo approccio qualosa stessi usando gli [alias](https://github.com/avajs/ava/issues/1011).
+
+
+###### `webpack.config.js`
+
+```js
+const path = require('path');
+const nodeExternals = require('webpack-node-externals');
+module.exports = {
+	entry: ['test.js'],
+	target: 'node',
+	output: {
+		path: path.resolve(__dirname, '_build'),
+		filename: 'test.js'
+	},
+	externals: [nodeExternals()],
+	module: {
+		rules: [
+			{
+				test: /\.(js|jsx)$/,
+				use: 'babel-loader',
+				options: {
+					cacheDirectory: true
+				}
+			}
+		]
+	}
+};
+```
+
+I punti salienti della configurazione sopra sono `target: 'node'`, che ignora le istruzioni `require` specifiche per Node.js (es. `fs`, `path`, etc.) e `externals: nodeModules`, che inibisce webpack dall'includere moduli specifici di Node.js che potrebbero dare problemi.
+
+Ora puoi eseguire `$ ava _build/test.js` per eseguire i test inclusi nell'output.
+
+### File di test multipli
+
+Per questo scenario le cose sono un po' più complicate. Noi raccomandiamo l'uso di [babel-register](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/babelrc.md) almeno fino a quando non ci sono grandi problemi di performance.
+
+I possibili approcci in questo caso sono:
+
+- [Usare un riferimento ai sorgenti precompilati nei test](#usare-un-riferimento-ai-sorgenti-precompilati-nei-test)
+
+- [Usare un singolo entry file](#usare-un-singolo-entry-file)
+
+- [Usare più entry file](#usare-piu-entry-file)
+
+- [Testare sorgenti precompilati](#testare-sorgenti-precompilati)
+
+#### Usare un riferimento ai sorgenti precompilati nei test
+
+I file sorgenti possono essere compilati nella cartella `_src` e poi chiamati nei file di test. Anche se questa opzione è la meno elegante, ha buone prestazioni ed il flusso può essere ottimizzato con il [watch mode di `babel-cli`](https://babeljs.io/docs/usage/cli/#babel).
+
+```js
+// Before
+import fresh from '../src';
+
+// After
+import fresh from '../_src';
+```
+
+### Usare un singolo entry file
+
+Si possono compilare più file di test in un singolo file. Questo approccio ha le performance migliori anche se ha alcuni svantaggi. Tutti i test saranno infatti inclusi in un unico file, quindi potrebbe essere più complicato sapere quale file di test è fallito, poichè AVA non potrà più mostrare le informazioni sul file di test originario. Un altro svantaggio riguarda la perdita dell'[isolamento dei processi](https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md#isolamento-de-processi).
+
+###### `webpack.config.js`
+
+[Risposta originaria da Stack Overflow](http://stackoverflow.com/questions/32874025/how-to-add-wildcard-mapping-in-entry-of-webpack/34545812#34545812)
+```js
+const path = require('path');
+const glob = require('glob');
+const nodeExternals = require('webpack-node-externals');
+
+module.exports = {
+	target: 'node',
+	entry: glob.sync('./test/**/*.js'),
+	output: {
+		path: path.resolve(__dirname, '_build'),
+		filename: 'tests.js'
+	},
+	externals: [nodeExternals()],
+	module: {
+		rules: [
+			{
+				test: /\.(js|jsx)$/,
+				use: {
+					loader: 'babel-loader',
+					options: {
+						cacheDirectory: true
+					}
+				}
+			}
+		]
+	}
+};
+```
+
+<details>
+<summary>Comparazione del report di errore</summary>
+
+```
+# Before
+  aggregations-test » cardinality-agg » sets precision_threshold option
+  E:\Projects\repos\elastic-builder\test\_macros.js:167
+   166:         const expected = getExpected(keyName, recursiveToJSON(propValue));
+   167:         t.deepEqual(value, expected);
+   168:     }
+  Difference:
+      Object {
+        my_agg: Object {
+          cardinality: Object {
+    -       precision_threshol: 5000,
+    +       precision_threshold: 5000,
+          },
+        },
+      }
+# After
+  sets precision_threshold option
+  E:\Projects\repos\elastic-builder\_build\tests.js:106
+   105:                     column: 21
+   106:                 }
+   107:             },
+  Difference:
+      Object {
+        my_agg: Object {
+          cardinality: Object {
+    -       precision_threshol: 5000,
+    +       precision_threshold: 5000,
+          },
+        },
+      }
+```
+
+</details>
+
+### Usare più entry file
+
+È possibile configurare webpack per generare più entry file. Questo approccio aiuta nel mantenere i nomi dei file di test così che il report in caso di errore siano più facili da interpretare. Lo svantaggio in questo caso è che ogni entry file avrà la sua copia dei file sorgenti. Il risultato finale sarà quindi una serie di file molto più grandi. Le performance in questo caso saranno [molto basse](https://github.com/avajs/ava/pull/1385#issuecomment-304684047) alla prima esecuzione.
+
+###### `webpack.config.js`
+
+```js
+const path = require('path');
+const glob = require('glob');
+const nodeExternals = require('webpack-node-externals');
+
+const entryObj = glob.sync('./test/**/*.js')
+	.reduce((acc, file) => {
+		acc[path.basename(file, path.extname(file))] = file;
+		return acc;
+	}, {});
+
+module.exports = {
+	target: 'node',
+	entry: entryObj,
+	output: {
+		path: path.resolve(__dirname, '_build'),
+		filename: '[name].js'
+	},
+	externals: [nodeExternals()],
+	module: {
+		rules: [
+			{
+				test: /\.(js|jsx)$/,
+				use: {
+					loader: 'babel-loader',
+					options: {
+						cacheDirectory: true
+					}
+				}
+			}
+		]
+	}
+};
+```
+
+#### Testare sorgenti precompilati
+
+Questo approccio è sicuramente il più complesso ma ha una buona resa in termini di performance e mantiene i nomi dei file inalterati. Con questo approccio useremo la `babel-cli` per compilare i file sorgenti e preservare la struttura dei file. I percorsi dei file richiesti nei file di test verranno sovrascritti quando i file di test verranno compilati con webpack. L'esempio seguente è per una specifica struttura di file. A seconda di come siano organizzati i tuoi file sorgente e di test potresti aver bisogno di modificare un po' la configurazione dell'esempio.
+
+Struttura dei file
+
+```
+├───src
+│   ├───my-pkg-fldr
+│   │   ├───my-module.js
+│   │   └───index.js
+│   └───index.js
+└───test
+    ├───my-pkg-fldr
+    │   └───my-module.test.js
+    └───index.test.js
+# Struttura di file generata
+├───_src
+│   ├───my-pkg-fldr
+│   │   ├───my-module.js
+│   │   └───index.js
+│   └───index.js
+└───_build
+    ├───my-module.test.js
+    └───index.test.js
+```
+
+npm scripts:
+
+```js
+{
+	"scripts": {
+		"precompile-src": "cross-env NODE_ENV=test babel src --out-dir _src",
+		"precompile-tests": "cross-env NODE_ENV=test webpack --config webpack.config.test.js",
+		"pretest": "npm run precompile-src && npm run precompile-tests",
+		"test": "cross-env NODE_ENV=test nyc --cache ava _build --concurrency 3"
+	}
+}
+```
+
+###### `webpack.config.js`
+
+[Documentazione Webpack `externals`](https://webpack.js.org/configuration/externals/#function)
+
+```js
+const path = require('path');
+const glob = require('glob');
+const nodeExternals = require('webpack-node-externals');
+
+const entryObj = glob.sync('./test/**/*.js')
+	.reduce((acc, file) => {
+		acc[path.basename(file, path.extname(file))] = file;
+		return acc;
+	}, {});
+
+module.exports = {
+	target: 'node',
+	entry: entryObj,
+	output: {
+		path: path.resolve(__dirname, '_build'),
+		filename: '[name].js'
+	},
+	externals: [
+		nodeExternals(),
+		// Sovrascrivi i percorsi in require() usando `_src`
+		(context, request, callback) => {
+            // Questo è un po' complicate perchè i test non verranno messi esattamente
+            // come nella struttura originale
+			// test/index.test.js → _build/index.test.js
+				//=> ../src → ../_src
+			// test/my-pkg-fldr/my-module.test.js → _build/my-module.test.js
+				//=> ../../src → ../_src
+			if (request.includes('/src')) {
+				const requestReqwrite = request
+					.replace('/src', '/_src')
+					.replace('../../_src', '../_src');
+				return callback(null, `commonjs ${requestReqwrite}`);
+			}
+			callback();
+		}
+	]
+};
+```
\ No newline at end of file
diff --git a/it_IT/docs/recipes/react.md b/it_IT/docs/recipes/react.md
new file mode 100644
index 00000000..376f23ba
--- /dev/null
+++ b/it_IT/docs/recipes/react.md
@@ -0,0 +1,148 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [react.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/react.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-2cb79c7fb78b66228297358846395c3a) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `react.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Testare componenti React
+
+Translations: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/react.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/react.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/react.md)
+
+## Configurare Babel
+
+Il primo passo per configurare Babel per transpilare codice JSX nei test aggiungendo una sezione AVA al tuo `package.json`:
+
+```json
+{
+	"ava": {
+		"require": ["babel-register"],
+		"babel": "inherit"
+	},
+	"babel": {
+		"presets": ["react"]
+	}
+}
+```
+
+Puoi trovare maggiori informazioni su come configurare Babel con AVA nella ricetta [babelrc](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/babelrc.md).
+
+## Usare [Enzyme](https://github.com/airbnb/enzyme)
+
+Vediamo come utilizzare AVA con uno delle librerie di testing React più popolari: [Enzyme](https://github.com/airbnb/enzyme).
+Se intendi utilizzare solamente il [rendering superficiale dei componenti](https://facebook.github.io/react/docs/test-utils.html#shallow-rendering), allora non hai bisogno di seguire questa configurazione aggiuntiva.
+
+Per prima cosa installa [i pacchetti Enzyme necessari](https://github.com/airbnb/enzyme/#installation):
+
+```console
+$ npm install --save-dev enzyme react-addons-test-utils react-dom
+```
+
+Puoi quindi usare Enzyme da subito:
+
+```js
+import test from 'ava';
+import React from 'react';
+import {shallow} from 'enzyme';
+
+const Foo = ({children}) =>
+	<div className="Foo">
+		<span className="bar">bar</span>
+		{children}
+		<span className="bar">bar</span>
+	</div>;
+
+Foo.propTypes = {
+	children: React.PropTypes.any
+};
+
+test('has a .Foo class name', t => {
+	const wrapper = shallow(<Foo/>);
+	t.true(wrapper.hasClass('Foo'));
+});
+
+test('renders two `.Bar`', t => {
+	const wrapper = shallow(<Foo/>);
+	t.is(wrapper.find('.bar').length, 2);
+});
+
+test('renders children when passed in', t => {
+	const wrapper = shallow(
+		<Foo>
+			<div className="unique"/>
+		</Foo>
+	);
+	t.true(wrapper.contains(<div className="unique"/>));
+});
+```
+
+Enzyme ha anche degli helper `mount` e `render` per fare testing in un ambiente browser reale. Se vuoi utilizzare questi helpers avrai bisogno di configurare un ambiente di testing per AVA. Fai riferimento alla ricetta [browser testing](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/browser-testing.md) su come fare.
+
+Per vedere un esempio di AVA e Enzyme configurati in un ambiente browser di testing, guarda questo [progetto di esempio](https://github.com/adriantoine/ava-enzyme-demo).
+
+Questo è un esempio base su come integrare Enzyme e AVA. Per maggiori informazioni su come usare Enzyme per il testing di componenti React fai riferimento alla [documentazione di Enzyme](http://airbnb.io/enzyme/).
+
+## Usare helpers per JSX
+
+Un altro approccio per il testing di componenti React è l'uso del pacchetto [`react-element-to-jsx-string`](https://github.com/algolia/react-element-to-jsx-string) per comparare alberi DOM tra loro come stringhe. La libreria [`jsx-test-helpers`](https://github.com/MoOx/jsx-test-helpers) è molto utile per il [rendering superficiale dei componenti](https://facebook.github.io/react/docs/test-utils.html#shallow-rendering) e per la conversione del codice JSX in stringhe di testo per usare le asserzioni AVA nel testing di componenti React.
+
+```console
+$ npm install --save-dev jsx-test-helpers
+```
+
+Esempio di utilizzo:
+
+```js
+import test from 'ava';
+import React from 'react';
+import {renderJSX, JSX} from 'jsx-test-helpers';
+
+const Foo = ({children}) =>
+	<div className="Foo">
+		<span className="bar">bar</span>
+		{children}
+		<span className="bar">bar</span>
+	</div>;
+
+Foo.propTypes = {
+	children: React.PropTypes.any
+};
+
+test('renders correct markup', t => {
+	const actual = renderJSX(<Foo/>);
+	const expected = JSX(
+		<div className="Foo">
+			<span className="bar">bar</span>
+			<span className="bar">bar</span>
+		</div>
+	);
+	t.is(actual, expected);
+});
+
+test('renders children when passed in', t => {
+	const actual = renderJSX(
+		<Foo>
+			<div className="unique"/>
+		</Foo>
+	);
+	const expected = JSX(
+		<div className="Foo">
+			<span className="bar">bar</span>
+			<div className="unique"/>
+			<span className="bar">bar</span>
+		</div>
+	);
+	t.is(actual, expected);
+});
+```
+
+Devi usare le variabili `actual` e `expected` come mostrato sopra a causa di un problema con [`power-assert` e la gestione di JSX](https://github.com/power-assert-js/power-assert/issues/34).
+
+questo è un esempio base su come utilizzare `jsx-test-helpers` con AVA. Per esempi più avanzati con questa libreria guarda [questo file di test con note](https://github.com/MoOx/jsx-test-helpers/blob/master/src/__tests__/index.js).
+
+[Questo semplice progetto](https://github.com/MoOx/jsx-test-helpers) mostra una configurazione minimale tra AVA e `jsx-test-helpers`.
+
+## Utilizzare altre librerie di asserzione
+
+In AVA puoi utilizzare ogni libreria di asserzione che vuoi e ci sono già alcune pronte per il testing di componenti React. Questa è una lista di librerie che funzionano bene con AVA:
+
+- [`expect-jsx`](https://github.com/algolia/expect-jsx) ([Esempio](https://github.com/avajs/ava/issues/186#issuecomment-161317068))
+- [`unexpected-react`](https://github.com/bruderstein/unexpected-react) ([Semplice progetto con un esempio di output](https://github.com/adriantoine/ava-unexpected-react-demo))
\ No newline at end of file
diff --git a/it_IT/docs/recipes/typescript.md b/it_IT/docs/recipes/typescript.md
index 8270dac9..4740b010 100644
--- a/it_IT/docs/recipes/typescript.md
+++ b/it_IT/docs/recipes/typescript.md
@@ -1,20 +1,20 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [typescript.md](https://github.com/avajs/ava/blob/master/docs/recipes/typescript.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `typescript.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [typescript.md](https://github.com/avajs/ava/blob/master/docs/recipes/typescript.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `typescript.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # TypeScript
 
-Traduzioni: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/typescript.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/docs/recipes/typescript.md)
+Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/typescript.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/typescript.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/typescript.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/docs/recipes/typescript.md), [简体中文](https://github.com/avajs/ava-docs/blob/master/zh_CN/docs/recipes/typescript.md)
 
 AVA è dotato nativamente con un file definitione TypeScript. Questo permette agli sviluppatori di utilizzare TypeScript per scrivere i test.
 
 ## Configurazione
 
-Come prima cosa installa il compilatore TypeScript [tsc](https://github.com/Microsoft/TypeScript).
+Come prima cosa installa il [TypeScript](https://github.com/Microsoft/TypeScript) (se è già installato, controlla che la versione sia 2.1 o successiva).
 
 ```
-$ npm install --save-dev tsc
+$ npm install --save-dev typescript
 ```
 
 Crea un file [`tsconfig.json`](https://github.com/Microsoft/TypeScript/wiki/tsconfig.json). Questo file serve per le opzioni del compilatore richieste per la compilazione del progetto o dei file di test.
@@ -56,6 +56,35 @@ test(async (t) => {
 });
 ```
 
+## Attivare [`context`](https://github.com/avajs/ava#test-context)
+
+Il tipo predefinito di `t.context` è [`any`](https://www.typescriptlang.org/docs/handbook/basic-types.html#any). AVA espone un'interfaccia `RegisterContextual<T>` da utilizzare per applicare il tipo specifico a `t.context`. Questo può aiutare a rintracciare errori a tempo di compilazione:
+
+```ts
+import * as ava from 'ava';
+
+function contextualize<T>(getContext: () => T): ava.RegisterContextual<T> {
+	ava.test.beforeEach(t => {
+		Object.assign(t.context, getContext());
+	});
+
+	return ava.test;
+}
+
+const test = contextualize(() => ({ foo: 'bar' }));
+
+test.beforeEach(t => {
+	t.context.foo = 123; // error:  Type '123' is not assignable to type 'string'
+});
+
+test.after.always.failing.cb.serial('very long chains are properly typed', t => {
+	t.context.fooo = 'a value'; // error: Property 'fooo' does not exist on type '{ foo: string }'
+});
+
+test('an actual test', t => {
+	t.deepEqual(t.context.foo.map(c => c), ['b', 'a', 'r']); // error: Property 'map' does not exist on type 'string'
+});
+```
 
 ## Esegui i test
 
diff --git a/it_IT/docs/recipes/vue.md b/it_IT/docs/recipes/vue.md
new file mode 100644
index 00000000..c76ee12f
--- /dev/null
+++ b/it_IT/docs/recipes/vue.md
@@ -0,0 +1,82 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [vue.md](https://github.com/sindresorhus/ava/blob/master/docs/recipes/vue.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-09533a825d46c23878919cd6e9bb1182) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `vue.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Testare componenti Vue.js
+
+Traduzioni: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/vue.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/vue.md)
+
+## Dipendenze
+
+- [Estensione per gli hook require](https://github.com/jackmellis/require-extension-hooks):
+	- `npm i --save-dev require-extension-hooks require-extension-hooks-vue require-extension-hooks-babel`
+
+- [browser-env](browser-testing.md)
+	- `npm i --save-dev browser-env`
+
+## Setup
+
+Il primo passo consiste nell'impostare un helper per configurare l'ambiente per la traspilazione dei file `.vue` e la simulazione di un ambiente browser:
+
+```json
+{
+	"ava": {
+		"babel": "inherit",
+		"require": [
+			"./test/helpers/setup.js"
+		]
+	}
+}
+```
+
+```js
+// ./test/helpers/setup.js
+
+// Setup browser environment
+require('browser-env')();
+const hooks = require('require-extension-hooks');
+const Vue = require('vue');
+
+// Setup Vue.js to remove production tip
+Vue.config.productionTip = false;
+
+// Setup vue files to be processed by `require-extension-hooks-vue`
+hooks('vue').plugin('vue').push();
+// Setup vue and js files to be processed by `require-extension-hooks-babel`
+hooks(['vue', 'js']).plugin('babel').push();
+```
+
+Puoi trovare maggiori informazioni su come configurare Babel con AVA nella ricetta [babelrc](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/babelrc.md).
+
+## Snapshot test semplice
+
+```js
+import test from 'ava';
+import Vue from 'vue';
+import Component from 'component.vue';
+
+test('renders', t => {
+	const vm = new Vue(Component).$mount();
+	const tree = {
+		$el: vm.$el.outerHTML
+	};
+	t.snapshot(tree);
+});
+```
+
+## Report di code coverage
+
+Come primo passo segui la ricetta [code coverage]
+Follow the [coverage reporting recipe](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/code-coverage.md), poi aggiungi l'estensione `.vue` alla configurazione di `nyc` per instrumentare i file `.vue`.
+
+```json
+{
+	"nyc": {
+		"extension": [
+			".js",
+			".vue"
+		]
+	}
+}
+```
\ No newline at end of file
diff --git a/it_IT/docs/recipes/watch-mode.md b/it_IT/docs/recipes/watch-mode.md
index 46799baf..29c75384 100644
--- a/it_IT/docs/recipes/watch-mode.md
+++ b/it_IT/docs/recipes/watch-mode.md
@@ -1,7 +1,7 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [watch-mode.md](https://github.com/avajs/ava/blob/master/docs/recipes/watch-mode.md). Qui c'è il [link](https://github.com/avajs/ava/compare/3201b1b4ff80ff75f0e1c288ca7da22f92c9b814...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `watch-mode.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [watch-mode.md](https://github.com/avajs/ava/blob/master/docs/recipes/watch-mode.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `watch-mode.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # Watch mode
 
@@ -64,40 +64,43 @@ Non dimenticare che il reporter TAP non è disponibile quando si utilizza il wat
 
 ## Requisiti
 
-AVA utilizza [`chokidar`] come watcher per i file. È configurato come dipendenza opzionale perchè in taluni scenari `chokidar` non può essere istallato. La modalità watch non è disponibile se `chokidar` non viene/può essere installato, verrà quiandi mostrato il seguente messaggio:
-
-> The optional dependency chokidar failed to install and is required for --watch. Chokidar is likely not supported on your platform.
-> La dipendenza opzionale chokidar ha fallito l'istallazione ed è stato richiesto da --watch. Probabilmente Chokidar non è ancora supportato dalla tua piattaforma.
-
-Fai riferimento alla [documentazione di `chokidar`][`chokidar`] per trovare soluzioni a questo problema.
+AVA utilizza [`chokidar`] come watcher per i file. Qualora vedessi avvertimenti riguardo dipendenze opzionali che non possono essere installate, il watcher funzionerà comunque. Qualora ci dovessero essere problemi con l'installazione di `chokidar` fai riferimento alla sezione *[Problemi di installazione]* nella documentazione di `chokidar` su come risolverli.
 
 ## File sorgente e di test
 
 AVA distingue tra i *file sorgente* e i *file di test*. Come puoi immaginare i *file di test* contengono i tuoi test. I *file sorgente* sono tutti quei file che sono richiesti per eseguire i test, che siano file sorgente o file fixtures.
 
-AVA controlla automaticamente le modifiche nei file di test, `package.json`, ed ogni file `.js`. Ignorerà invece file in [specifiche cartelle]
+AVA controlla automaticamente le modifiche nei file di test, i file snapshot, `package.json`, ed ogni file `.js`. Ignorerà invece file in [specifiche cartelle]
 (https://github.com/novemberborn/ignore-by-default/blob/master/index.js) come predefinito nel modulo [`ignore-by-default`].
 
-Puoi configurare il pattern per i file sorgente nella [sezione `ava` del tuo file `package.json`], utilizzando l'opzione `source`. Questa è la via consigliata, altrimenti puoi usare anche il [parametro CLI `--source`].
+Puoi configurare il pattern per i file sorgente nella [sezione `ava` del tuo file `package.json`], utilizzando l'opzione `source`.
 
 Puoi specificare pattern per file in cartelle che verrebbero altrimenti ignorati, es. puoi specificare `node_modules/some-dependency/*.js` per tutti i file `.js` nella cartella `node_modules/some-dependency` come file sorgente, anche se normalmente i file in `node_modules` sono ignorati. Tieni presente che solamente nomi esatti di cartella verranno considerati, quindi `{bower_components,node_modules}/**/*.js` non funzionerà.
 
-Se i tuoi test devono scrivere su disco potrebbero entrare in conflitto con il watcher, che farà ri-eseguire i tuoi test. Se questo avvenisse dovrai usare il parametro `--source`.
+Se i tuoi test devono scrivere su disco potrebbero entrare in conflitto con il watcher, che farà ri-eseguire i tuoi test. Se questo avvenisse dovrai configurare correttamente i pattern per i file sorgente.
 
-## Tracciare le dipendenza
+## Tracciare le dipendenze
 
 AVA traccia quale da file sorgente ogni tuo test dipende. Se cambi questa dipendenza solamente il file di test che dipende verrà rieseguito. AVA ri-eseguirà tutti i test se non può determinare quale file di test dipende dal file sorgente modificato.
 
-Il tracciamento delle dipendenze funziona per i moduli richiesti. Estensioni personalizzate e transpiler sono supportati, a patto che vengano caricati utilizzando il [parametro CLI `--require`] e non dall'interno dei tuoi file di test. I file caricati tramite il modulo `fs` non verranno tracciati.
+Il tracciamento delle dipendenze funziona per i moduli richiesti. Estensioni personalizzate e transpiler sono supportati, a patto che vengano [aggiunti nel file `package.json`] e non dall'interno dei tuoi file di test. I file caricati tramite il modulo `fs` non verranno tracciati.
 
 ## Watch mode ed il modificator `.only`
 
 Il [modificatore `.only`] disabilità l'algoritmo di tracciamento delle dipendenze in watch mode. Quando avviene un cambiamento, tutti i test con il modificatore `.only` verranno rieseguiti, a prescindere dalla dipendenza dei test dal file sorgente modificato.
 
+## Watch mode e integrazione continua (CI)
+
+Se esegui AVA nel tuo ambiente di CI con il watch mode attivo, l'esecuzione terminerà con un errore (`Error : Watch mode is not available in CI, as it prevents AVA from terminating.`). AVA non deve essere eseguito con l'opzione `--watch` (`-w`) quando in un ambiente di CI poichè è previsto che processi in un ambiente di CI vengano terminati quando completati, mentre AVA con l'opzione `--watch` non farà terminare il processo.
+
 ## Riesecuzione manuale dei test
 
 Puoi rapidamente rieseguire tutti i testi digitando <kbd>r</kbd> sulla linea di comando, seguito da <kbd>Invio</kbd>.
 
+## Aggiornare snapshots
+
+Puoi aggiornare snapshots che falliscono digitando <kbd>u</kbd> sulla linea di comando, seguito da <kbd>Invio</kbd>.
+
 ## Debugging
 
 Qualche volta la modalità watch può comportarsi in modo anomalo, rieseguendo tutti i test quando invece pensavi che sarebbe stato eseguito un unico test. Per capirne il motivo puoi abilitare la modalità debug. È consigliato utilizzare il reporter `verbose`:
@@ -122,7 +125,8 @@ $ npm test -- --watch --verbose
 La modalità watch è una funzionalità relativamente nuova e ci potrebbero essere ancora alcuni difetti. Per favore [notifica](https://github.com/avajs/ava/issues) qualsiasi problema che riscontri. Grazie!
 
 [`chokidar`]: https://github.com/paulmillr/chokidar
+[Problemi di installazione]: https://github.com/paulmillr/chokidar#install-troubleshooting
 [`ignore-by-default`]: https://github.com/novemberborn/ignore-by-default
-[parametro CLI `--require`]: https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md#cli
-[parametro CLI `--source`]: https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md#cli
+[modificatore `.only`]: https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md#eseguire-test-specifici
+[aggiunti nel file `package.json`]: https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md#configurazione
 [sezione `ava` del tuo file `package.json`]: https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md#configurazione
diff --git a/it_IT/docs/recipes/when-to-use-plan.md b/it_IT/docs/recipes/when-to-use-plan.md
index c9875969..4b722700 100644
--- a/it_IT/docs/recipes/when-to-use-plan.md
+++ b/it_IT/docs/recipes/when-to-use-plan.md
@@ -1,12 +1,12 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [when-to-use-plan.md](https://github.com/avajs/ava/blob/master/docs/recipes/when-to-use-plan.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `when-to-use-plan.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [when-to-use-plan.md](https://github.com/avajs/ava/blob/master/docs/recipes/when-to-use-plan.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `when-to-use-plan.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 
 # Quando usare `t.plan()`
 
-Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/when-to-use-plan.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/when-to-use-plan.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/docs/recipes/when-to-use-plan.md),  [Português](https://github.com/avajs/ava-docs/blob/master/pt_BR/docs/recipes/when-to-use-plan.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/docs/recipes/when-to-use-plan.md)
+Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/docs/recipes/when-to-use-plan.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/recipes/when-to-use-plan.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/when-to-use-plan.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/docs/recipes/when-to-use-plan.md),  [Português](https://github.com/avajs/ava-docs/blob/master/pt_BR/docs/recipes/when-to-use-plan.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/docs/recipes/when-to-use-plan.md), [简体中文](https://github.com/avajs/ava-docs/blob/master/zh_CN/docs/recipes/when-to-use-plan.md)
 
 Una delle differenze sostanziali tra AVA e [`tap`](https://github.com/tapjs/node-tap)/[`tape`](https://github.com/substack/tape) è il comportamento della funzione `t.plan()`. In AVA, `t.plan()` è solamente usato per verificare che il numero previsto di asserzioni sia rispettato, ma non termina automaticamente il test.
 
@@ -54,10 +54,6 @@ test(async t => {
 });
 ```
 
-## Buon uso di `t.plan()`
-
-Ci sono molti casi in cui vale la pena usare `t.plan()`.
-
 ### Promesse con un handler `.catch()`
 
 ```js
@@ -65,13 +61,23 @@ test(t => {
 	t.plan(2);
 
 	return shouldRejectWithFoo().catch(reason => {
-		t.is(reason.message, 'Hello') // Valuta t.throws() se sei solamente interessato al messaggio d'errore
+		t.is(reason.message, 'Hello');
 		t.is(reason.foo, 'bar');
 	});
 });
 ```
 
-In questo caso `t.plan()` è usato per assicurarsi che il codice all'interno del blocco `catch` sia eseguito. In molti casi, dovresti considerare l'uso dell'asserzione `t.throws()`, ma è considerato un uso accettabile di `t.plan()` poichè `t.throws()` ti permette solamente di verificare la proprietà `message` dell'errore.
+In questo caso `t.plan()` viene usato per assicurarsi che il codice nel blocco `catch` venga eseguito.
+
+Un'alternativa migliore può essere l'utilizzo di `t.throws()` e `async`/`await`, poichè il codice diventa più semplice da leggere e comprendere:
+
+```js
+test(async t => {
+	const reason = await t.throws(shouldRejectWithFoo());
+	t.is(reason.message, 'Hello');
+	t.is(reason.foo, 'bar');
+});
+```
 
 ### Assicurarsi che un blocco catch venga eseguito
 
@@ -82,13 +88,17 @@ test(t => {
 	try {
 		shouldThrow();
 	} catch (err) {
-		t.is(err.message, 'Hello') // Valuta t.throws() se sei solamente interessato al messaggio d'errore
+		t.is(err.message, 'Hello');
 		t.is(err.foo, 'bar');
 	}
 });
 ```
 
-Come già specificato nel blocco `try`/`catch` sopra, utilizzare l'asserzione `t.throws()` è generalmente una scelta migliore, anche se ti permette solamente di verificare la proprietà `message` dell'errore.
+Come già detto nellesempio precedente, è meglio utilizzare `t.throws()` con `async`/`await`.
+
+## Uso appropriato di `t.plan()`
+
+`t.plan()` aggiunge valore ai tuoi test nei casi seguenti.
 
 ### Assicurati che callback multiple vengano eseguite
 
diff --git a/it_IT/docs/specs/001 - Improving language support.md b/it_IT/docs/specs/001 - Improving language support.md
new file mode 100644
index 00000000..fa13a046
--- /dev/null
+++ b/it_IT/docs/specs/001 - Improving language support.md	
@@ -0,0 +1,84 @@
+___
+**Nota del traduttore**
+
+Questa è la traduzione del file [001 - Improving language support.md](https://github.com/avajs/ava/blob/master/docs/specs/001%20-%20Improving%20language%20support.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-01b90728d033fffd4c5cdacef3735d16) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `001 - Improving language support.md` nella lista dei file modificati, questa traduzione è aggiornata).
+___
+# Migliorare il supporto ad altri linguaggi
+
+Traduzioni: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/docs/specs/001%20-%20Improving%20language%20support.md),
+ [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/specs/001%20-%20Improving%20language%20support.md),
+
+Questo è un [RFC] per proporre un miglioramento del supporto per Babel, React e TypeScript in AVA.
+
+## Enunciazione del problema
+
+Integrare AVA in progetto con Bable può essere veramente compilicato. Gli utenti devono configurare `babel-core/register` per consentire agli helper e ai file sorgente di essere compilati correttamente. Configurare le modalità di compilazione dei file di test non è chiaro. I file sorgente potrebbero [avere configurazioni diverse quando caricati in AVA][source options reason] rispetto a quelle applicate in produzione.
+Non esiste alcun supporto per scrivere test e codice sorgente in altri linguaggi come TypeScript o JSX.
+
+## Contesto
+
+AVA utilizza Bable per permettere agli utenti di usare [ES2015](https://babeljs.io/docs/plugins/preset-es2015/) e [stage-2](https://babeljs.io/docs/plugins/preset-stage-2/). I messaggi di asserzione sono ["aumentati" mediante l'uso di un plugin Babel](https://github.com/avajs/ava/pull/46), ed un altro plugin viene utilizzato per controllare  [l'uso improprio di `t.throws()`](https://github.com/avajs/ava/pull/742).
+
+Inizialmente `babel/register` era [usato direttamente](https://github.com/avajs/ava/pull/23) e applicato ai file di test, agli helper e ai file sorgente. Successivamente il comportamento è stato cambiato per [transpilare solo i file di test](https://github.com/avajs/ava/issues/50). Il comportamento iniziale era stato [considerato  come bug](https://github.com/avajs/ava/issues/108#issuecomment-151245367), probabilmente perchè AVA compilava i fie sorgente contro l'intento originario dell'utente.
+
+In seguito gli utenti vennero [consigliati di aggiungere `babel-core/register` alla lista di moduli richiesti in automatico all'esecuzione dei test](https://github.com/avajs/ava#transpiling-imported-modules). Questo ha mostrato però che caricare Babel in ogni processo è un compito molto lento, e furono fatti vari tentativi per compilare i [file helper][1078] e i [file sorgente][945] nel processo AVA principale.
+
+Nel mentre AVA ha deciso di allontanarsi dalla pratica di utilizzo di `babel/register` e iniziato ad utilizzare Babel in modo diretto. Un [livello di cache](https://github.com/avajs/ava/pull/352) è stato quindi costruito per il codice compilato in Babel.
+
+AVA controlla solo file che hanno un'estensione `.js`, anche se il pattern glob fornito include altri file. Per definizione questo previene [la selezione di file JSX e TypeScript](https://github.com/avajs/ava/issues/631).
+
+## Soluzioni possibili
+
+La soluzione [#945][945] prova a compilare tutte le dipendenze dei file di test (quidi file helper e file sorgente) nel processo principale. Senza considerare alcuni bug non ancora risolti, un grande svantaggio risiede nell'impossibilità di supportare `require` dinamici, poichè questi avvengono nei processi figli durante l'esecuzione e non nel processo principale dove sono compilati. Inoltre risolvere tutte le dipendenze aggiunge un certo costo di gestione alla funzionalità alto.
+La soluzione [#1078][1078] permette di precompilare i file helper nel processo principale, esattamente come avviene per i file di test. Questo funziona decisamente bene ma è limitato unicamente ai file helper.
+Con 
+The conclusione raggiunta nella [#631][631 conclusione] fu di permettere diverse estensioni per i file di test. Sfortunatamente abilitare unicamente altre estensioni non è sufficiente a risolvere il problema iniziale. AVA infatti assume che questi file contengano codice JavaScript al loro interno, quindi non sarà in grado di eseguire codice JSX o TypeScript.
+La soluzione [#1122](https://github.com/avajs/ava/pull/1122) è un avanzamento della [proposta contenuta nella #631][631 conclusione] con una configurazione relativa all'estensione `.ts` e compilando automaticamente questi file di test con TypeScript.
+Sfortunatamente non è ancora chiaro come questo approccio possa funzionare senza incorrere a svantaggi prestazionali già incontrati con Babel sopra. Inoltre i file di test che utilizzano TypeScript non godono di asserzioni avanzate e controlli per l'uso improprio di `.throws()`. Questa mancanza è molto difficile da comunicare agli utenti quando per abilitare TypeScript è sufficiente utilizzare unicamente l'opzione `extensions`.
+
+## Proposte specifiche
+
+AVA compila i file di test e helper in modo predefinito. Per fare ciò utilizza Babel, ma solo i plugin con le proposte allo stage-4 e con standard ratificati (al momento è ES2016 pi`u le proposte che hanno raggiunto lo stage-4 e che verranno incluse in ES2017). questo vuol dire che AVA supporta la stessa sintassi di ESLint.
+
+AVA non applica più il plugin [`babel-plugin-transform-runtime`](https://babeljs.io/docs/plugins/transform-runtime/). Questo plugin crea degli alias per variabili globali in ES2015 che sono non necessarie, poichè al momento la piattaforma target di AVA è Node.js 4. Questo è un [problema piuttosto comune](https://github.com/avajs/ava/issues/1089).
+
+Le altre trasformazioni che AVA utilizza, come `babel-plugin-espower` e `babel-plugin-ava-throws-helper` saranno incluse in un unico `babel-preset-ava` che verrà automaticamente applicato. (Se fosse necessario potremmo aggiungere una opzione per applicare `babel-plugin-transform-runtime` insieme ad una [logica di riscrittura](https://github.com/avajs/ava/blob/033d4dcdcbdadbf665c740ff450c2a775a8373dc/lib/babel-config.js#L53:L61) al momento applicata per correggere i percorsi. È necessario utilizzare un approccio di attesa-e-controllo per questa aggiunta.)
+
+### Progetti Babel
+
+La sezione precedente è basata sull'assunzione che AVA venga utilizzato su progetto JavaScript che non richiedano compilazione. Molti utenti però già utilizzano un flusso Bable già configurato e desiderano usare AVA senza precompilare i loro file sorgenti. Semplicemente, impostare `"babel": true` nella configurazione AVA abilita il supporto AVA per progetti Babel. I file di test e helper sono già compilati come descritto sopra, ma i file sorgenti verranno ora compilati automaticamente.
+AVA controlla per la presenza dei file `package.json` e `.babel.rc` nella cartella del progetto per determinare la configurazione Babel utilizzata per compilare i file sorgente (l'obiettivo è quello di estrarre un oggetto di configurazione Babel da questi due file). Questa descritta è una semplificazione del processo di gestione della configurazione Babel, dove si ricerca per i file di configurazione vicini ai file da compilare. Utilizzando questi due file AVA può creare una cache di compilazione senza caricare Babel ogni volta, e allo stesso tempo poter ricompilare i file sorgenti se qualcosa dovesse cambiare.
+La gestione di progetti Babel da parte di AVA può essere più precisa qualora si passi un oggetto di configurazione invece al valore `true` descritto sopra:
+* `compileSources: true | false`: stabilisce se compilare o meno i file sorgenti. Il valore predefinito è `true`.
+* `extensions: "js" | ["js", "jsx", ...]`: Specifica quali file sono consentiti. Può essere usato per estendere i tipi di file da caricare. Il valore predefinito è `"js"`.
+* `sourceOptions: {}`: permette di specificare [configurazioni Babel] precise per i file sorgenti. In questo contesto `babelrc: true` dichiara di unire la configurazione con le configurazioni trovate nei file `package.json` e `.babelrc` nel progetto. Il valore predefinito di `babelrc` è `true`.
+* `testOptions: {}`: permette di specificare [configurazioni Babel] per compilare i file helper e test. Quando questa configurazione viene specificata, la configurazione predefinita in AVA per Babel viene disabilitata e viene utilizzata questa. Come con `sourceOptions` anche in questo caso `babelrc` ha come valore predefinito `true`. Impostare il valore `presets: ["ava"]` se si vogliono utilizzare le trasformate Babel di AVA con questa configurazione.
+`sourceOptions` può essere usata per estendere una configurazione Babel condivisa così da poter caricare i file sorgenti nei test AVA. Ad esempio un utente potrebbe [dipendere da webpack per far funzionare la sintassi moduli ES2015 quando compilano, ma richiedere l'uso di `babel-plugin-transform-es2015-modules-commonjs` quando si usano i sorgenti nei test AVA][perchè avere configurazione sorgenti].
+Le opzioni `sourceOptions` e `testOptions` nella [configurazione Babel] potrebbero contenere valori `ignore` e `only`. In questo caso verranno usati per determinare se un file richiede la compilazione. Non vengono usati per la selezione dei file o per il watch mode.
+
+## Compilazione
+
+Sulla base di questo [proof of concept](https://github.com/avajs/ava/pull/1082) la compilazione Babel viene spostata nel processo del test stesso. Se i file sorgenti devono essere compilati allora AVA caricherà i suoi hook *require* piuttosto che usare `babel-core/register`.
+Le opzioni Babel per i file di test, helper e sorgenti sono preparati nel processo principale e poi condivisi nei sotto processi. Dei valori hash verranno creati da queste configurazioni e salvati nella cache come succede per altre dipendenze utilizzate per i test. I sotto processi utilizzerà l'hash dei file per controllare la cache per usare valore precedentemente salvati. (Poichè i sotto processi vengono eseguiti in concorrenza, bisogna essere sicuri che possano leggere i valori completi nella cache e non parziali. Va bene se lo stesso file viene compilato più volte.)
+
+## Supporto per progetti TypeScript
+
+Il supporto per TypeScript può essere fornito più o meno nello stesso modo del supporto avanzato per Babel descritto sopra. Configurando `"typescript": true` nella configurazione AVA il supporto per TypeScript viene abilitato quindi l'estensione `.ts` funzionerà per i file di test, helper e file sorgente. Un oggetto di configurazione può essere utilizzato al posto di `true`:
+* `compileSources: true | false`: stabilisce se compilare o meno i file sorgenti. Il valore predefinito è `true`.
+* `extensions: "ts" | ["ts", "tsx", ...]`: Specifica quali file sono consentiti. Può essere usato per estendere i tipi di file da caricare. Il valore predefinito è `"ts"`.
+* `sourceOptions: {}`: permette di specificare [configurazioni TypeScript] precise per i file sorgenti. L'opzione `extends` ha come valore predefinito il file `tsconfig.json`, se viene trovato. È necessario configurarlo come `null` per evitare di estendere questo file.
+* `testOptions: {}`: permette di specificare [configurazioni TypeScript] per compilare i file helper e test. Il comportamento è lo stesso di `sourceOptions`, ma non esiste una configurazione predefinita per i file di test e helper in questo caso, al contrario dei progetti Babel.
+Le opzioni `sourceOptions` e `testOptions` nella [configurazione TypeScript] potrebbero contenere dei valori per `files`, `include` e `exclude`: questi valori non vengono utilizzati per selezionare i file o per il watch mode.
+
+## Per maggiori dettagli di implementazione
+
+Il supporto per Babel e TypeScript in AVA si possono utilizzare moduli Node.js distinti. L'interfaccia di questi moduli deve essere la stessa, così da semplificare l'integrazione con AVA.
+AVA offre il supporto per Babel in modo nativo, mentre è necessario installare dipendenze aggiuntive per attivare il supporto per TypeScript. Qualora il supporto per TypeScript venisse abilitato ma AVA non riesce a trovare le dipendenze richieste, verrà mostrato un errore con informazioni utili per correggere il problema.
+I file selezionati duranti l'esecuzione dei test sarà la combinazione delle configurazioni trovate in `babel` e `typescript`.
+I percorsi relativi dichiarati in `sourceOptions` e `testOptions` dovranno fare riferimento [al percorso originario del file `package.json`.](https://github.com/avajs/ava/issues/707).
+[1078]: https://github.com/avajs/ava/pull/1078
+[631 conclusione]: https://github.com/avajs/ava/issues/631#issuecomment-248659780
+[945]: https://github.com/avajs/ava/pull/945
+[configurazione Babel]: https://babeljs.io/docs/usage/api/#options
+[perchè avere configurazione sorgenti]: https://github.com/avajs/ava/issues/1139#issuecomment-267969417
+[configurazione TypeScript]: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html
\ No newline at end of file
diff --git a/it_IT/maintaining.md b/it_IT/maintaining.md
index e4e9b3f5..904b321a 100644
--- a/it_IT/maintaining.md
+++ b/it_IT/maintaining.md
@@ -1,7 +1,7 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [mantaining.md](https://github.com/avajs/ava/blob/master/mantaining.md). Qui c'è il [link](https://github.com/avajs/ava/compare/195390ec1db90cf7d394407c846a69fbaa08806d...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `mantanaing.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [mantaining.md](https://github.com/avajs/ava/blob/master/mantaining.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `mantanaing.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
 # Manutenzione [![Dependency Status](https://david-dm.org/avajs/ava.svg)](https://david-dm.org/avajs/ava) [![devDependency Status](https://david-dm.org/avajs/ava/dev-status.svg)](https://david-dm.org/avajs/ava#info=devDependencies)
 
diff --git a/it_IT/readme.md b/it_IT/readme.md
index 3d5c7c40..e07c90b3 100644
--- a/it_IT/readme.md
+++ b/it_IT/readme.md
@@ -1,31 +1,37 @@
 ___
 **Nota del traduttore**
 
-Questa è la traduzione del file [readme.md](https://github.com/avajs/ava/blob/master/readme.md). Qui c'è il [link](https://github.com/avajs/ava/compare/3201b1b4ff80ff75f0e1c288ca7da22f92c9b814...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `readme.md` nella lista dei file modificati, questa traduzione è aggiornata).
+Questa è la traduzione del file [readme.md](https://github.com/avajs/ava/blob/master/readme.md). Qui c'è il [link](https://github.com/avajs/ava/compare/c09462c3e515c41da8177a3d9ba5fb0f19759653...master#diff-0730bb7c2e8f9ea2438b52e419dd86c9) dove si confrontano le differenze tra commit di riferimento di questa traduzione e l'ultimo commit di AVA sul branch master (Se si clicca sul link, e non si vede il file `readme.md` nella lista dei file modificati, questa traduzione è aggiornata).
 ___
-# ![AVA](https://github.com/avajs/ava/raw/master/media/header.png)
+# [![AVA](https://github.com/avajs/ava/raw/master/media/header.png)](https://ava.li)
 
 > Test runner futuristico
 
-[![Build Status: Linux](https://travis-ci.org/avajs/ava.svg?branch=master)](https://travis-ci.org/avajs/ava) [![Build status: Windows](https://ci.appveyor.com/api/projects/status/igogxrcmhhm085co/branch/master?svg=true)](https://ci.appveyor.com/project/avajs/ava/branch/master) [![Coverage Status](https://coveralls.io/repos/avajs/ava/badge.svg?branch=master&service=github)](https://coveralls.io/github/avajs/ava?branch=master) [![Gitter](https://badges.gitter.im/join_chat.svg)](https://gitter.im/avajs/ava)
+[![Build Status: Linux](https://travis-ci.org/avajs/ava.svg?branch=master)](https://travis-ci.org/avajs/ava) [![Build status: Windows](https://ci.appveyor.com/api/projects/status/e7v91mu2m5x48ehx/branch/master?svg=true)](https://ci.appveyor.com/project/ava/ava/branch/master) [![Coverage Status](https://coveralls.io/repos/github/avajs/ava/badge.svg?branch=master)](https://coveralls.io/github/avajs/ava?branch=master) [![Dependency Status](https://dependencyci.com/github/avajs/ava/badge)](https://dependencyci.com/github/avajs/ava) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo) [![Gitter](https://badges.gitter.im/join_chat.svg)](https://gitter.im/avajs/ava)
 
-Nonostante Javascript si possa eseguire in un singolo thread, le operazioni di IO (Input/Output) in Node.js si possono eseguire in parallelo data la sua natura asincrona. AVA trae vantaggio da questa proprietà ed esegue in modo concorrente i tuoi test, portando forti benefici a pesanti test in IO. Inoltre, i file di test sono eseguiti in parallelo in processi distinti, offrendoti un miglioramento ulteriore delle prestazioni oltre che un ambiente isolato dove far girare ogni file di test. Passando da Mocha ad AVA in Pageres si è migliorato il tempo di esecuzione da 31 secondi a 11 secondi. Avendo test eseguiti in modo concorrente si è obbligati a scrivere test atomici, cioè test che non dipendono da un unico stato globale o lo stato impostato da test precedenti, che è grandioso!
+Nonostante Javascript si possa eseguire in un singolo thread, le operazioni di IO (Input/Output) in Node.js si possono eseguire in parallelo data la sua natura asincrona. AVA trae vantaggio da questa proprietà ed esegue in modo concorrente i tuoi test, ottenendo molti benefici per test pesanti in IO. Inoltre, i file di test sono eseguiti in parallelo in processi distinti, offrendoti un miglioramento ulteriore delle prestazioni, oltre che un ambiente isolato dove far girare ogni file di test. [Passando](https://github.com/sindresorhus/pageres/commit/663be15acb3dd2eb0f71b1956ef28c2cd3fdeed0) da Mocha ad AVA in Pageres si è migliorato il tempo di esecuzione da 31 secondi a 11 secondi. Con test eseguiti in modo concorrente si è obbligati a scrivere test atomici, cioè test che non dipendono da un unico stato globale o lo stato impostato da test precedenti, che è grandioso!
+
+![](https://github.com/avajs/ava/raw/master/media/mini-reporter.gif)
 
 *Leggi la nostra [guida per collaboratori](contributing.md) se pensi di contribuire (issue/PRs/etc).*
 
 Segui l'[account Twitter di AVA](https://twitter.com/ava__js) per le ultime notizie.
 
-Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/readme.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/readme.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/readme.md), [Portugués](https://github.com/avajs/ava-docs/blob/master/pt_BR/readme.md)
+Translations: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/readme.md), [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/readme.md), [Italiano](https://github.com/avajs/ava-docs/blob/master/it_IT/readme.md), [日本語](https://github.com/avajs/ava-docs/blob/master/ja_JP/readme.md), [한국어](https://github.com/avajs/ava-docs/blob/master/ko_KR/readme.md), [Português](https://github.com/avajs/ava-docs/blob/master/pt_BR/readme.md), [Русский](https://github.com/avajs/ava-docs/blob/master/ru_RU/readme.md), [简体中文](https://github.com/avajs/ava-docs/blob/master/zh_CN/readme.md)
 
 
-## Tabla de contenidos
+## Indice dei contenuti
 
 - [Uso](#uso)
 - [Uso della CLI](#cli)
+- [Debugging](#debugging)
+- [Reporters](#reporters)
 - [Configurazione](#configurazione)
 - [Documentazione](#documentazione)
 - [API](#api)
 - [Asserzioni](#asserzioni)
+- [Snapshot testing](#snapshot-testing)
+- [Consigli](#consigli)
 - [Domande frequenti](#domande-frequenti)
 - [Ricette](#ricette)
 
@@ -37,15 +43,17 @@ Traduzioni: [Español](https://github.com/avajs/ava-docs/blob/master/es_ES/readm
 - Esegue i test in modo concorrente
 - Obbliga a scrivere test atomici
 - Non ha variabili globali implicite
+- Include i type definition per TypeScript & Flow
+- [Asserzioni magiche](#asserzioni-magiche)
 - [Ambiente isolato per l'esecuzione di ogni file di test](#isolamento-dei-processi)
-- [Scrivi i tuoi test usando ES2015](#supporto-a-es2015)
+- [Scrivi i tuoi test usando ES2017](#supporto-a-es2017)
 - [Supporto per Promesse](#supporto-per-promesse)
 - [Supporto per Generatori](#supporto-per-generatori)
 - [Supporto per funzioni asincrone](#supporto-per-funzioni-asincrone)
 - [Supporto per Oggetti Osservabili](#supporto-per-oggetti-osservabili)
 - [Messaggi di asserzione avanzati](#migliorare-messaggi-delle-asserzioni)
-- [Produzione TAP opzionale](#produzione-tap-opzionale)
-- [Stack trace chiari](#stack-trace-chiari)
+- [Reporter TAP](#reporter-tap)
+- [Migrazione automatica da altri test runner](https://github.com/avajs/ava-codemods#migrating-to-ava)
 
 
 ## Sintassi per test
@@ -63,13 +71,22 @@ test(t => {
 
 #### Aggiungi AVA al tuo progetto
 
-Istalla AVA globalmente e poi eseguilo con `--init` per aggiungere AVA al tuo `package.json`:
+Installa AVA globalmente e poi eseguilo con `--init` per aggiungere AVA al tuo `package.json`. [Yarn](https://yarnpkg.com/) fornisce al momento prestazioni migliori rispetto a npm per l'installazione. Considera l'uso di [Yarn](https://yarnpkg.com/en/docs/install) se l'installazione dovesse essere troppo lenta.
 
+```console
+$ yarn global add ava
+$ ava --init
 ```
+
+Se preferisci usare npm invece:
+
+```console
 $ npm install --global ava
 $ ava --init
 ```
 
+Modifica il tuo file `package.json` come il seguente:
+
 ```json
 {
 	"name": "awesome-package",
@@ -77,18 +94,24 @@ $ ava --init
 		"test": "ava"
 	},
 	"devDependencies": {
-		"ava": "^0.11.0"
+		"ava": "^0.19.0"
 	}
 }
 ```
 
-Ogni parametro passato dopo `--init` viene aggiunto al `package.json`.
+Ogni parametro passato dopo `--init` viene aggiunto alla configurazione in `package.json`.
 
-#### Istallazione manuale
+#### Installazione manuale
 
-È anche possibile istallare AVA direttamente
+È anche possibile installare AVA direttamente:
 
+```console
+$ yarn add --dev ava
 ```
+
+Se preferisci usare npm invece:
+
+```console
 $ npm install --save-dev ava
 ```
 
@@ -98,7 +121,6 @@ Dovrai configurare la sezione di `test` nel `package.json` per usare `ava` corre
 
 Crea un file `test.js` nella cartella principale del progetto con il seguente contenuto:
 
-
 ```js
 import test from 'ava';
 
@@ -114,8 +136,6 @@ test('bar', async t => {
 });
 ```
 
-<img src="https://github.com/avajs/ava/blob/master/media/screenshot.png" width="150" align="right">
-
 #### Esegui il test
 
 ```
@@ -132,8 +152,6 @@ AVA integra un sistema intelligente di watch. [Guarda più opzioni nella cartell
 
 ## CLI
 
-![](https://github.com/avajs/ava/raw/master/media/screenshot-mini-reporter.gif)
-
 ```
 $ ava --help
 
@@ -146,11 +164,16 @@ $ ava --help
     --serial, -s     Run tests serially - (Esegui i test in serie)
     --require, -r    Module to preload (Can be repeated) - ( Moduli da precaricare (può essere ripetuto) )
     --tap, -t        Generate TAP output - (Genera l'output TAP)
-    --verbose, -v    Enable verbose output - (Abilita la modalità verbosa)
+    --verbose, -v    Enable verbose output - (Abilita la modalità prolissa)
     --no-cache       Disable the transpiler cache - (Disabilita la cache per il transpiler)
+    --no-power-assert       Disable Power Assert - (Disabilita i power assert)
+    --color                 Force color output - (Forza i colori nell'output)
+    --no-color              Disable color output - (Disabilita i colori nell'output)
     --match, -m      Only run tests with matching title (Can be repeated) - (Esegui solamente i test con il titolo corrispondente ad un pattern (può essere ripetuto))
     --watch, -w      Re-run tests when tests and source files change - (Esegui nuovamente i test quando i file di test o sorgente cambiano)
-    --source, -S     Pattern to match source files so tests can be re-run (Can be repeated) - (Pattern utilizzato per trovare file sorgente così che i test possano venire ri-eseguiti (può essere ripetuto) )
+    --timeout, -T           Set global timeout - (Imposta un timeout globale)
+    --concurrency, -c       Maximum number of test files running at the same time (EXPERIMENTAL) - (Imposta il limita massimo di test che possono essere eseguiti in concorrenza (ANCORA SPERIMENTALE))
+    --update-snapshots, -u  Update snapshots - (Aggiorna snapshots)
 
   Examples
     ava
@@ -168,6 +191,58 @@ $ ava --help
 
 Le cartelle sono ricorsive, tutti i file `*.js` vengono considerati automaticamente file di test. Cartelle con i seguenti nomi sono sempre ignorate: `fixtures`, `helpers` e `node_modules`. Allo stesso modo file il cui nome inizia per `_` vengono ignorati, consentendo di avere file di aiuto/supporto nella stessa cartella dei tuoi file.
 
+Quando viene usato `npm test` è possibile passare parametri posizionali `npm test test2.js`, ma i `flags` devono essere passati in questo modo `npm test -- --verbose`.
+
+## Debugging
+
+AVA esegue i test in processi figli del processo principale (child processes), perciò per fare il debugging dei test avrai bisogno di questo trucco:
+
+```console
+$ node --inspect node_modules/ava/profile.js some/test/file.js
+```
+
+### Consigli specifici per il debugging
+
+- [Chrome DevTools](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-chrome-devtools.md)
+- [WebStorm](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-webstorm.md)
+- [Visual Studio Code](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-vscode.md)
+
+## Reporters
+
+### Mini-reporter
+
+Il reporter predefinito è il mini-reporter
+
+<img src="https://github.com/avajs/ava/raw/master/media/mini-reporter.gif" width="460">
+
+### Reporter completo
+
+Per abilitare il reporter più completo e prolisso, usa il `flag` `--verbose`. Questo reporter viene utilizzato automaticamente in ambienti CI a meno che il [reporter TAP](#reporter-tap) non venga abilitato.
+
+<img src="https://github.com/avajs/ava/raw/master/media/verbose-reporter.png" width="294">
+
+### Reporter TAP
+
+AVA suporta il formato TAP ed è compatibile con [ogni reporter TAP](https://github.com/sindresorhus/awesome-tap#reporters). Per abilitare l'output TAP utilizza il `flag` `--tap`.
+
+```console
+$ ava --tap | tap-nyan
+```
+
+<img src="https://github.com/avajs/ava/raw/master/media/tap-reporter.png" width="420">
+
+Attenzione che il reporter TAP non è disponibile quando AVA viene eseguito in [watch mode](#osserva-le-modifiche-ai-file-test).
+
+### Asserzioni magiche
+
+AVA aggiunge parziali di codice mostrando le differenze tra il codice attuale e quello previsto in modo chiaro. Se i valori nelle asserzioni sono oggetti o Array, solamente la differenza verrà mostrata, al fine di rimuovere il rumore e focalizzarsi sul problema trovato. Il codice mostrato avrà anche lo style della sintassi! Se stai comparando stringhe di testo, che siano su riga singola o multipla, AVA mostrerà un tipo di output diverso, evidenziando la parte aggiunta o mancante nella stringa.
+
+![](https://github.com/avajs/ava/raw/master/media/magic-assert-combined.png)
+
+### Stack trace puliti
+
+AVA rimuove automaticamente righe di codice non importanti dagli stack trace, facilitando e velocizzando la ricerca della fonte del problema, come mostrato sopra.
+
 ## Configurazione
 
 Tutte le opzioni per la CLI possono essere configurati nella sezione `ava` del tuo `package.json`. Questo permette di modificare il comportamento predefinito del comando `ava`, in modo da evitare di ripetere continuamente le stesse opzioni dalla riga di comando.
@@ -187,8 +262,11 @@ Tutte le opzioni per la CLI possono essere configurati nella sezione `ava` del t
       "*oo",
       "!foo"
     ],
+    "concurrency": 5,
     "failFast": true,
+    "failWithoutAssertions": false,
     "tap": true,
+    "powerAssert": false,
     "require": [
       "babel-register"
     ],
@@ -199,21 +277,25 @@ Tutte le opzioni per la CLI possono essere configurati nella sezione `ava` del t
 
 Gli argomenti passati alla CLI avranno sempre la precedenza rispetto alla configurazione nel file `package.json`.
 
+Vedi la sezione [supporto a ES2017](#support-a-es2017) per dettagli sull'opzione `babel`.
+
 ## Documentazione
 
 I test vengono eseguiti in modo concorrente. Puoi definire sia test sincroni che asincroni. I test sono considerati sincroni a meno che una promessa o un oggetto osservabile vengano restituiti.
 
 Noi raccomandiamo *particolarmente* l'uso di [funzioni asincrone](#supporto-per-funzioni-asincrone). Queste aiutano a scrivere codice asincrono in modo conciso e leggibile, restituendo implicitamente una promessa così non devi farlo tu.
 
-Se non puoi usare promesse o oggetti osservabili, puoi sempre utilizzare la "modalità callback" definendo il tuo test con la seguente sintassi `test.cb([title], fn)`. I test definiti con questa modalità **dovranno** manualmente terminare con il comando `t.end()`. Questa modalità è principalmente pensata per testare API che utilizzano callback.
+Se non puoi usare promesse o oggetti osservabili, puoi sempre utilizzare la "modalità callback" definendo il tuo test con la seguente sintassi `test.cb([title], fn)`. I test definiti con questa modalità **dovranno** manualmente terminare con il comando `t.end()`. Questa modalità è principalmente pensata per testare API che utilizzano callback. Ad ogni modo raccomandiamo di usare strumenti come [promisifying](https://github.com/sindresorhus/pify) per trasformare API da callback a Promesse, poichè i test diventano più facile da gestire e mantenere.
 
 I test devono essere definiti in modo sincrono. Non possono essere definiti in istruzioni tipo `setTimeout`, `setInterval`, etc...
 
-I file di test vengono eseguiti da dentro la loro cartella, quindi `process.cwd()` equivale sempre a `__dirname`. Puoi utilizzare percorsi relativi invece della funzione `path.join(__dirname, 'relative/path)`.
+Ava prova ad eseguire i file di test impostando la cartella corrente nel percorso che contiene il file `package.json`.
 
 ### Come creare test
 
-Per creare un test devi utilizzare la funzione `test` importata da AVA, aggiungi un titolo e una callback. La funzione callback verrà eseguita quando il tuo test verrà eseguito. Come argomento della callback viene fornito un [contesto di esecuzione](#t) come primo ed unico argomento. Per convenzione questo parametro è chiamato `t`.
+Per creare un test devi utilizzare la funzione `test` importata da AVA, aggiungi un titolo (opzionale) e una callback. La funzione callback verrà eseguita quando il tuo test verrà eseguito. Come argomento della callback viene fornito un [contesto di esecuzione](#t) come primo ed unico argomento. Per convenzione questo parametro è chiamato `t`.
+
+**Nota**: per utilizzare i [messaggi di asserzione avanzati](#migliorare-messaggi-delle-asserzioni) correttamente, il primo argomento **deve** essere oblligatoriamente `t`.
 
 ```js
 test('name', t => {
@@ -246,6 +328,8 @@ test(function name(t) {
 
 Le soglie per le asserzioni garantiscono che i test passino esclusivamente quando un numero specifico di asserzioni è stato eseguito. Possono aiutare a scoprire casi in cui i test terminano anticipatamente. Inoltre se un test eccede il numero soglia impostato di asserzioni allora viene considerato come fallito: questo è comodo in quei casi in cui si usano asserzioni in callback o cicli.
 
+Se non viene specificato un piano di asserzioni, il test fallirà se non vengono eseguiti test. Configura l'opzione `failWithoutAssertions` a `false` nella [configurazione AVA nel `package.json`](#configurazione) per disabilitare questo comportamento.
+
 Da notare che, a differenza di [tap](https://www.npmjs.com/package/tap) e [tape](https://www.npmjs.com/package/tape), AVA non termina automaticamente il test quando il numero di asserzioni pianificate viene raggiunto.
 
 Questi sono esempio di test che terminano con successo:
@@ -294,9 +378,7 @@ test(t => {
 
 ### Eseguire test in serie
 
-I test vengono eseguiti in modo concorrente in automatico. A volte però avrai bisogno di scrivere test che non siano eseguiti in modo concorrente.
-
-In questi rari casi si può utilizzare il modificatore `.serial`, che obbligherà l'esecuzione dei test seriali *prima* dell'esecuzione dei test concorrenti.
+I test vengono eseguiti in modo concorrente in automatico. A volte però avrai bisogno di scrivere test che non siano eseguiti in modo concorrente. In questi rari casi si può utilizzare il modificatore `.serial`, che obbligherà l'esecuzione dei test seriali *prima* dell'esecuzione dei test concorrenti.
 
 ```js
 test.serial(t => {
@@ -415,13 +497,28 @@ Puoi utilizzare il modificatore `.todo` quando vuoi lasciare un nota sull'intenz
 test.todo('will think about writing this later');
 ```
 
+### Test markating come `failing`
+
+È possibile usare il modificatore `.failing` per documentare problemi con il tuo codice che necessitano attenzione. Test marcati come `failing` vengono eseguiti come normali test, ma AVA si aspetta che questi falliscano, quindi l'esecuzione non verrà interotta se questi falliscono. Se un test segnato come `failing` dovesse passare l'esecuzione in questo caso verrà interrotta ed un errore verrà stampato, spiegandone il motivo e suggerendo di rimuovere il modificatore `.failing`.
+
+Questa funzionalità permette di fare il merge di test `.failing` prima ancora che il fix venga incluso senza interrompere ambienti di CI. Pu`o anche essere utilizzata questa funzionalità per dimostrare un bug tramite un commit, anche se non si sa come risolvere il problema/bug riportato.
+
+```js
+// Vedi: github.com/user/repo/issues/1234
+test.failing('demonstrate some bug', t => {
+	t.fail(); // Il test conterà come passato con successo
+});
+```
+
 ### Before & after hooks
 
 AVA ti permette di registrare delle funzioni hook da eseguire prima e dopo i tuoi test. Questo ti permette di creare e/o distruggere lo scenario per i tuoi test.
 
-`test.before()` permette di registrare una funzione da eseguire prima del primo test nel tuo file di test. Allo stesso modo `test.after()` permette di eseguire una funzione dopo l'esecuzione dell'ultimo test.
+`test.before()` permette di registrare una funzione da eseguire prima del primo test nel tuo file di test. Allo stesso modo `test.after()` permette di eseguire una funzione dopo l'esecuzione dell'ultimo test. Usa l'hook `test.after.always()` per registrare una funzione che verrà **sempre** eseguita una volta che i tuoi test e gli altri hook sono stati completati. Gli hook `.always()` sono eseguiti in tutti i casi, sia di successo o fallimenti durante l'esecuzione, e sono quindi il candidato ideale per ripulire l'ambiente al termine dell'esecuzione. Esistono due eccezioni a questo tipo di comportamento: se si usa l'opzione `--fail-fast` AVA interromperà l'esecuzione dei test al primo fallimento incontrato, senza eseguire alcun hook successivo, quindi neanche `.always()`. Errori non catturati (*Uncaught exceptions*) producono un crash dell'esecuzione dei test, prevenendo l'esecuzione degli hook `.always()`.
+
+`test.beforeEach()` permette di registrare una funzione da eseguire prima di ogni singolo test nel tuo file di test. Allo stesso modo `test.afterEach()` permette di eseguire una funzione dopo l'esecuzione di ciascun test. Usa l'hook `test.afterEach.always()` per registrare un hook da chiamare anche quando altri test o hook falliscono. Gli hook `.always()` sono ideali per ripulire l'ambiente al termine dell'esecuzione.
 
-`test.beforeEach()` permette di registrare una funzione da eseguire prima di ogni singolo test nel tuo file di test. Allo stesso modo `test.afterEach()` permette di eseguire una funzione dopo l'esecuzione di ciascun test.
+**Nota**: Se l'opzione `--fail-fast` viene utilizzata, AVA interromperà l'esecuzione immediatamente dopo il primo fallimento e l'hook `.always()` **non** verrà eseguito.
 
 Allo stesso modo di `test()` questi metodi possono avere un titolo opzionale e una funzione callback. Il titolo viene mostrato se l'hook fallisce l'esecuzione, mentre alla funzione callback viene passato il parametro [contesto di esecuzione](#t).
 
@@ -440,6 +537,10 @@ test.after('cleanup', t => {
     // eseguito al termine di tutti i test
 });
 
+test.after.always('guaranteed cleanup', t => {
+	// eseguito in ogni caso, anche se un test fallisce
+});
+
 test.beforeEach(t => {
     // eseguito prima di ciascun test
 });
@@ -448,6 +549,10 @@ test.afterEach(t => {
     // eseguito dopo ciascun test
 });
 
+test.afterEach.always(t => {
+	// eseguito dopo ogni test in ogni caso, che fallisca o passi con successo
+});
+
 test(t => {
     // semplice test
 });
@@ -479,6 +584,8 @@ Non dimenticare che `beforeEach` e `afterEach` vengono eseguiti appena prima e d
 
 Ricorda che AVA esegue ciascun file di test in un processo isolato. Potresti non aver bisogno di ripristinare lo stato originale dello stato nel'hook `after` poichè verrebbe chiamato non appena prima della chiusura del processo.
 
+#### Contesto dei test
+
 Gli hook `beforeEach` e `afterEach` possono condividere lo stesso contesto con il test:
 
 ```js
@@ -519,12 +626,62 @@ test.only.serial(...);
 
 Questo ti permette di aggiungere temporaneamente `.skip` o `.only` alla fine di un test o hook senza dover fare altre modifiche.
 
+### Macro per i test
+
+È possibile passare parametri aggiuntivi quando si dichiara un test. Questa funzionalità è utile per creare macro riutilizzabili in più test.
+
+```js
+function macro(t, input, expected) {
+	t.is(eval(input), expected);
+}
+
+test('2 + 2 = 4', macro, '2 + 2', 4);
+test('2 * 3 = 6', macro, '2 * 3', 6);
+```
+
+È possibile costruire un titolo di un test in modo programmatico assegnando una funzione `title` alla macro:
+
+```js
+function macro(t, input, expected) {
+	t.is(eval(input), expected);
+}
+
+macro.title = (providedTitle, input, expected) => `${providedTitle} ${input} = ${expected}`.trim();
+
+test(macro, '2 + 2', 4);
+test(macro, '2 * 3', 6);
+test('providedTitle', macro, '3 * 3', 9);
+```
+
+Il parametro `providedTitle` ha una stringa vuota come valore predefinito, qualora l'utente non fornisse alcun titolo. Questa funzionalità permette la concatenazione di stringhe senza preoccuparsi di valori `null` o `undefined`. Vale comunque la pena fare attenzione al fatto che una stringa vuota ha un valore "falso" in JavaScript, si può quindi sfruttare questo per scrivere espressioni come `if(providedTitle) {...}`.
+
+È anche possibile passare una lista (Array) di funzioni macro ad un test:
+
+```js
+const safeEval = require('safe-eval');
+
+function evalMacro(t, input, expected) {
+	t.is(eval(input), expected);
+}
+
+function safeEvalMacro(t, input, expected) {
+	t.is(safeEval(input), expected);
+}
+
+test([evalMacro, safeEvalMacro], '2 + 2', 4);
+test([evalMacro, safeEvalMacro], '2 * 3', 6);
+```
+
+L'uso delle macro è incoraggiato rispetto alla costruzione di generatori di codice di test ([ecco un esempio](https://github.com/avajs/ava-codemods/blob/47073b5b58aa6f3fb24f98757be5d3f56218d160/test/ok-to-truthy.js#L7-L9) di codice da sostituire con una macro). Le macro sono progettate per effettuare analisi statica del tuo codice, con benefici in termini di performance, migliore integrazione nell'IDE e nelle regole del linter.
+
 ### Personalizzare asserzioni
 
 Puoi utilizzare ogni modulo di asserzioni invece o in aggiunta al modulo integrato, a patto che lanci un'eccezione quando un'asserzione fallisce.
 
 L'uso di un modulo esterno non fornisce lo stesso tipo d'esperienza d'uso di [quella integrata](#asserzioni), e allo stesso modo la [soglia per le asserzioni](#soglia-per-le-asserzioni) non funzionerà ([issue #25](https://github.com/avajs/ava/issues/25)).
 
+Dovrai quindi configurare AVA per not far fallire i test qualora non fossero presenti asserzioni, poichè AVA non può predire se un asserzione personalizzata sia passata o meno. Configura l'opzione `failWithoutAssertions` a `false` nella [configurazione di AVA nel `package.json`](#configurazione).
+
 ```js
 import assert from 'assert';
 
@@ -533,21 +690,17 @@ test(t => {
 });
 ```
 
-### Supporto a ES2015
+### Supporto a ES2017
 
-AVA fornisce un supporto integrato per ES2015 mediante [Babel 6](https://babeljs.io). Scrivi i tuoi test con ES2015, non c'è bisogno di altra impostazione da aggiungere. Puoi utilizzare qualunque versione di Babel nel tuo progetto. AVA utilizza una versione propria di Babel integrata preimpostata con [`es2015`](http://babeljs.io/docs/plugins/preset-es2015/) e [`stage-2`](http://babeljs.io/docs/plugins/preset-stage-2/), e con i plugin [`espower`](https://github.com/power-assert-js/babel-plugin-espower) e [`transform-runtime`](https://babeljs.io/docs/plugins/transform-runtime/).
+AVA fornisce un supporto integrato per ES2017 mediante [Babel 6](https://babeljs.io). Scrivi i tuoi test in ES2017, non c'è bisogno di altra impostazione da aggiungere. Puoi utilizzare qualunque versione di Babel nel tuo progetto. AVA utilizza una versione propria di Babel integrata preimpostata con [`@ava/stage-4`](https://github.com/avajs/babel-preset-stage-4) e [`@ava/transform-test-files`](https://github.com/avajs/babel-preset-transform-test-files).
 
 La configurazione corrispondente in Babel per il setup di AVA è la seguente:
 
 ```json
 {
   "presets": [
-    "es2015",
-    "stage-2",
-  ],
-  "plugins": [
-    "espower",
-    "transform-runtime"
+    "@ava/stage-4",
+    "@ava/transform-test-files"
   ]
 }
 ```
@@ -581,7 +734,7 @@ In aggiunta puoi utilizzare la speciale keyword `"inherit"`. Questa fa sì che A
 	   ]
    },
    "ava": {
-	   "babel": "inherit",
+	   "babel": "inherit"
    },
 }
 ```
@@ -592,13 +745,15 @@ Da notare che AVA applicherà *sempre* i plugin [`espower`] (https://github.com/
 
 AVA include i typings per TypeScript. La configurazione del transpiler dovrà però essere fatta manualmente. Quando imposterai nel file `tsconfig.json` `module` su `commonjs`, TypeScript troverà automaticamente la definizione dei tipi per AVA. Dovrai impostare `target` su `es2015` per poter utilizzare le promesse e le funzioni asincrone.
 
+Per maggiori informazioni vedi la ricetta AVA per [TypeScript](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/typescript.md).
+
 ### Usare il transpiler per i moduli importati
 
-AVA al momento utilizza il transpiler solamente per i test che richiedi di eseguire. *Non verrà utilizzato il transpiler per i moduli importati al di fuori dei test*. Benchè ci sia una ragione valida per questo comportamento, potrebbe non essere quel che ci si aspetta.
+AVA al momento utilizza il transpiler solamente per i test che richiedi di eseguire, e i file helper per i test (in particolare quei file il cui nome inizia per `_` o che si trovano nella cartella `helpers`). *Non verrà utilizzato il transpiler per i moduli importati al di fuori dei test*. Benchè ci sia una ragione valida per questo comportamento, potrebbe non essere quel che ci si aspetta.
 
-Come soluzione alternativa, utilizzando Babel, si può utilizzare il suo [require hook](https://babeljs.io/docs/usage/require/) per i moduli importati sul momento. Esegui AVA con `--require babel-register` (vedi [CLI](#cli) ) o [aggiungi l'impostazione nel tuo `package.json`](#configurazione).
+Come soluzione alternativa, utilizzando Babel, si può utilizzare il suo [require hook](https://babeljs.io/docs/usage/require/) per i moduli importati sul momento. Per aggiungerlo [configura l'impostazione nel tuo `package.json`](#configurazione).
 
-Puoi anche utilizzare il transpiler per i tuoi moduli in un processo separato e utilizzare i file prodotti invece dei sorgenti nei tuoi test.
+Puoi anche utilizzare il transpiler per i tuoi moduli in un processo separato e utilizzare i file prodotti invece dei sorgenti nei tuoi test. Per un esempio vedi [qui](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/precompiling-with-webpack.md).
 
 ### Supporto per Promesse
 
@@ -670,34 +825,33 @@ test.cb(t => {
 });
 ```
 
-### Produzione TAP opzionale
-
-AVA può produrre output TAP mediante l'opzione `--tap` per l'utilizzo di ogni [TAP reporter](https://github.com/sindresorhus/awesome-tap#reporters).
-
-```
-$ ava --tap | tap-nyan
-```
-
-<img src="https://github.com/avajs/ava/blob/master/media/tap-output.png" width="398">
+### Timeout globale
 
-### Stack trace chiari
+È possibile impostare un timeout globale con l'opzione `--timeout`.
+Il timeout in AVA ha un funzionamento diverso che negli altri test framework.
+AVA reimposta a 0 il timer dopo l'esecuzione di ogni test, forzando i test a terminare se non vengono ricevuti altri risultati di test entro il timeout specificato.
 
-AVA nasconde automaticamente righe non attinenti ai tuoi test nello stack trace, permettendoti di trovare la sorgente di ogni errore molto più rapidamente.
-
-<img src="https://github.com/avajs/ava/blob/master/media/stack-traces.png" width="300">
+È possibile impostare i timeout con un formato leggibile:
 
+```console
+$ ava --timeout=10s # 10 secondi
+$ ava --timeout=2m # 2 minuti
+# ava --timeout=100 # 100 millisecondi
+```
 
 ## API
 
-### test([titolo], callback)
-### test.serial([titolo], callback)
-### test.cb([titolo], callback)
-### test.only([titolo], callback)
-### test.skip([titolo], callback)
-### test.before([titolo], callback)
-### test.after([titolo], callback)
-### test.beforeEach([titolo], callback)
-### test.afterEach([titolo], callback)
+### `test([titolo], implementazione)`
+### `test.serial([titolo], implementazione)`
+### `test.cb([titolo], implementazione)`
+### `test.only([titolo], implementazione)`
+### `test.skip([titolo], implementazione)`
+### `test.todo(titolo)`
+### `test.failing([titolo], implementazione)`
+### `test.before([titolo], implementazione)`
+### `test.after([titolo], implementazione)`
+### `test.beforeEach([titolo], implementazione)`
+### `test.afterEach([titolo], implementazione)`
 
 #### titolo
 
@@ -705,7 +859,7 @@ Tipo: `string`
 
 Titolo del test.
 
-#### callback(t)
+#### implementazione(t)
 
 Tipo: `function`
 
@@ -715,7 +869,7 @@ Deve contere il corpo del test.
 
 Tipo: `oggetto`
 
-Il contesto di esecuzione di uno specifico test. Ogni callback di un test riceve un oggetto distinto. Contiene le asserzioni insieme ai metodi  `.plan(limite)` e `.end()`. `t.context` può contenere lo stato condiviso dall'hook `beforeEach`.
+Il contesto di esecuzione di uno specifico test. Ogni callback di un test riceve un oggetto distinto. Contiene le asserzioni insieme ai metodi  `.plan(limite)` e `.end()`. `t.context` può contenere lo stato condiviso dall'hook `beforeEach`. `t.title` restituisce il titolo del test.
 
 ###### t.plan(limite)
 
@@ -763,40 +917,134 @@ Accerta che il `valore` sia `false`.
 
 ### .is(valore, previsto, [messaggio])
 
-Accerta che il `valore` sia uguale a `previsto`.
+Accerta che il `valore` sia uguale a `previsto`. L'implementazione è basata su [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
 
 ### .not(valore, previsto, [messaggio])
 
-Accerta che il `valore` non sia uguale a `previsto`.
+Accerta che il `valore` non sia uguale a `previsto`. L'implementazione è basata su [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
 
-### .same(valore, previsto, [messaggio])
+### .deepEqual(valore, previsto, [messaggio])
 
-Accerta che il `valore` sia profondamente uguale a `previsto`.
+Accerta che il `valore` sia profondamente uguale a `previsto`. Fare riferimento a [Concordance](https://github.com/concordancejs/concordance) per maggiori dettagli. Funziona anche con [elementi React e `react-test-renderer`](https://github.com/concordancejs/react).
 
-### .notSame(valore, previsto, [messaggio])
+### .notDeepEqual(valore, previsto, [messaggio])
 
-Accerta che il `valore` non sia profondamente uguale a `previsto`.
+Accerta che il `valore` non sia profondamente uguale a `previsto`. L'opposto di `.deepEqual()`.
 
 ### .throws(function|promise, [errore, [message]])
 
 Accerta che `function` lanci un errore o che  la `promise` sia rifiutata.
 
-`errore` può essere un costruttore, espressione regolare, messaggio di errore o una funzione di validazione.
+`errore` può essere un costruttore, messaggio di errore, un'espressione regolare (*regex*) eseguita sul messaggio di errore o una funzione di validazione.
 
 Restituisce l'errore lanciato dalla `function` o dalla ragione del rifiuto della promessa `promise`.
 
+Ad esempio:
+
+```js
+const fn = () => {
+	throw new TypeError('🦄');
+};
+
+test('throws', t => {
+	const error = t.throws(() => {
+		fn();
+	}, TypeError);
+
+	t.is(error.message, '🦄');
+});
+```
+
+```js
+const promise = Promise.reject(new TypeError('🦄'));
+
+test('rejects', async t => {
+	const error = await t.throws(promise);
+	t.is(error.message, '🦄');
+});
+```
+
+Quando si esegue un test con una promessa bisogna attendere che l'asserzione sia completata:
+
+```js
+test('rejects', async t => {
+	await t.throws(promise);
+});
+```
+
 ### .notThrows(function|promise, [messaggio])
 
-Accerta che `function` non lanci un `errore` o che la promessa `promise` sia risolta.
+Accerta che `function` non lanci un `errore` o che la promessa `promise` non venga rifiutata con un errore.
+
+Come l'asserzione `.throws()`, quando si testa una promessa bisogna attendere che l'asserzione sia completata:
 
-### .regex(contenuto, regex, [message])
+```js
+test('rejects', async t => {
+	await t.notThrows(promise);
+});
+```
+
+### .regex(contenuto, regex, [messaggio])
 
 Accerta che `contenuto` corrisponda all'espressione regolare `regex`.
 
+### .notRegex(contenuto, regex, [messaggio])
+
+Accerta che `contenuto` non corrisponda all'espressione regolare `regex`.
+
 ### .ifError(errore, [messaggio])
 
 Accerta che `errore` sia falso.
 
+### .snapshot(previsto, [messaggio])
+### .snapshot(previsto, [opzioni], [messaggio])
+
+confronta il valore `previsto` con uno snapshot precedentemente registrato. Gli snapshot sono salvati per ogni test, quindi assicurati di assegnare un titolo univoco ad ogni test. In alternativa è possibile passare un oggetto `opzione` per selezionare uno snapshot specifico, ad esempio `{id: 'my snapshot'}`.
+
+## Snapshot testing
+
+AVA offre il supporto per lo snapshot testing, [allo stesso modo di Jest](https://facebook.github.io/jest/docs/snapshot-testing.html), mediante l'interfaccia [Asserzioni](#asserzioni). Puoi fare lo snapshot di ogni valore come di elementi React:
+
+```js
+// Il tuo componente
+const HelloWorld = () => <h1>Hello World...!</h1>;
+export default HelloWorld;
+```
+
+```js
+// Your test
+import test from 'ava';
+import render from 'react-test-renderer';
+import HelloWorld from '.';
+
+test('HelloWorld component', t => {
+	const tree = render.create(<HelloWorld/>).toJSON();
+	t.snapshot(tree);
+});
+```
+
+[Fai una prova con questo progetto esempio.](https://github.com/avajs/ava-snapshot-example)
+
+Gli snapshot vengono salvati insieme ai file di test. Se i tuoi test sono in una cartella `test` o `tests` allora gli snapshots saranno salvati in una cartella `snapshots`. Se i tuoi test sono in una cartella `__tests__` allora gli snapshot saranno salvati in una cartella `__snapshots__`.
+
+Qualora avessi un file `~/project/test/main.js` con dentro asserzioni per snapshot, AVA creerà due file:
+
+* `~/project/test/snapshots/main.js.snap`
+
+* `~/project/test/snapshots/main.js.md`
+
+dove il primo file contiene gli snapshot registrati che verranno usati per confronti futuri. Il secondo file contiene invece il *report degli snapshot*. Quando gli snapshot vengono aggiornati questo secondo file verrà aggiornato. Qualcosa venisse salvato sul sistema di versionamento del codice è possibile confrontare le diverse versioni per vedere le modifiche agli snapshot.
+
+AVA mostrerà il perchè un'asserzione sugli snapshot è fallita come segue:
+
+<img src="https://github.com/avajs/ava/raw/master/media/snapshot-testing.png" width="1048">
+
+Potrai quindi verificarlo sul tuo codice. Se le modifiche sono state intenzionali puoi usare il `flag` `--update-snapshot` (o `-u`) per aggiornare gli snapshot:
+
+```console
+$ ava --update-snapshots
+```
+
 ## Ignorare asserzioni
 
 Ogni asserzione può essere ignorata utilizzando il modificatore `.skip`. Le assegnazioni ignorate sono comunque considerate nel conto della soglia, quindi non c'è alcuna necessità di cambiarla.
@@ -840,7 +1088,8 @@ test(t => {
 ```
 
 Stamperà:
-```
+
+```console
 t.ok(a.test(b) || b === c)
        |    |     |     |
        |    "bar" "bar" "baz"
@@ -859,20 +1108,16 @@ Eseguire test in concorrenza comporta alcune complicazioni, ad esempio l'IO è u
 
 Generalmente, i test eseguiti in serie creano cartelle temporanee nella cartella di test corrente per poi eliminarla al termine. Questo approccio non funziona quando i testi sono eseguiti concorrentemente poichè i test potrebbero entrare in conflitto l'uno con l'altro. L'approccio migliore per questo tipo di problema è quello di utilizzare una nuova cartella temporanea per ciascun file di test. I moduli [`tempfile`](https://github.com/sindresorhus/tempfile) e [`temp-write`](https://github.com/sindresorhus/temp-write) possono aiutare in questo.
 
-### Debugging
-
-AVA esegue i test in concorrenza in automatico, il che lo rende sub-ottimale quando devi fare il debug di qualcosa. In questo caso esegui i test in serie con l'opzione `--serial`:
-
-```
-$ ava --serial
-```
-
 ### Code coverage
 
 Non è possibile utilizzare [`istanbul`](https://github.com/gotwarlost/istanbul) per il code coverage dato l'[uso di processi isolati](#isolamento-dei-processi) in AVA. In questo caso puoi usare [`nyc`](https://github.com/bcoe/nyc), poichè si tratta sostanzialmente di `istanbul` con il supporto per sub-processi.
 
 Dalla versione `5.0.0` utilizza anche le source maps per la rappresentazione del code coverage per il tuo codice sorgente, a prescindere dai file prodotti dal transpiler. Assicurati che il file che stai testando abbia una source map inline oppure referenzi un file source map. Se utilizzi `babel-register` puoi specificare l'opzione `sourceMaps` come `inline` nella configurazione Babel.
 
+### Errori comuni
+
+Abbiamo raccolto una lista comprensiva di [errori comuni](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/common-pitfalls.md) che puoi incontrare nell'uso di AVA. Se dovessi incontrare qualsiasi problema e pensi che questo sia piuttosto comune, lascia un commento su questa [issue](https://github.com/avajs/ava/issues/404).
+
 ## Domande frequenti
 
 ### Perchè non usare `mocha`, `tape`, `node-tap`?
@@ -901,13 +1146,21 @@ La [galassia di Andromeda](https://it.wikipedia.org/wiki/Galassia_di_Andromeda).
 
 ## Ricette
 
-- [Code coverage](docs/recipes/code-coverage.md)
-- [Test di Endpoint](docs/recipes/endpoint-testing.md)
-- [Quando usare `t.plan()`](docs/recipes/when-to-use-plan.md)
-- [Browser testing](docs/recipes/browser-testing.md)
-- [TypeScript](docs/recipes/typescript.md)
-- [Watch Mode](docs/recipes/watch-mode.md)
-
+- [Code coverage](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/code-coverage.md)
+- [Watch Mode](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/watch-mode.md)
+- [Test di Endpoint](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/endpoint-testing.md)
+- [Quando usare `t.plan()`](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/when-to-use-plan.md)
+- [Browser testing](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/browser-testing.md)
+- [TypeScript](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/typescript.md)
+- [Configurare Babel](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/babelrc.md)
+- [Testare componenti React](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/react.md)
+- [Testare componenti Vue.js](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/vue.md)
+- [JSPM and SystemJS](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/jspm-systemjs.md)
+- [Fare il debugging di test con Chrome DevTools](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-chrome-devtools.md)
+- [Fare il debugging di test con WebStorm](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-webstorm.md)
+- [Fare il debugging di test con Visual Studio Code](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/debugging-with-vscode.md)
+- [Precompilare file sorgente con webpack](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/precompiling-with-webpack.md)
+- [Test di integrazione con MongoDB in isolamento](https://github.com/avajs/ava-docs/blob/master/it_IT/docs/recipes/isolated-mongodb-integration-tests.md)
 
 ## Supporto
 
@@ -918,28 +1171,25 @@ La [galassia di Andromeda](https://it.wikipedia.org/wiki/Galassia_di_Andromeda).
 
 ## Guarda anche
 
+- [eslint-plugin-ava](https://github.com/avajs/eslint-plugin-ava) - Regole Lint per test AVA
 - [sublime-ava](https://github.com/avajs/sublime-ava) - Frammenti di codice per test con AVA
 - [atom-ava](https://github.com/avajs/atom-ava) - Frammenti di codice per test con AVA
 - [vscode-ava](https://github.com/samverschueren/vscode-ava) - Frammenti di codice per test con AVA
-- [eslint-plugin-ava](https://github.com/avajs/eslint-plugin-ava) - Regole Lint per test AVA
 - [gulp-ava](https://github.com/avajs/gulp-ava) - Esegui i test con gulp
 - [grunt-ava](https://github.com/avajs/grunt-ava) - Esegui i test con grunt
-- [fly-ava](https://github.com/pine/fly-ava) - Esegui i test con fly
-- [start-ava](https://github.com/start-runner/ava) - Esegui i test con start
-
-[Più moduli](https://github.com/avajs/awesome-ava#packages)
+- [Vedi qui per altri moduli](https://github.com/avajs/awesome-ava#packages)
 
 ## Link
 
 - [Compra adesivi di AVA](https://www.stickermule.com/user/1070705604/stickers)
-- [Lista fantastica](https://github.com/avajs/awesome-ava)
-
+- [Lista fantastica dedicata ad AVA](https://github.com/avajs/awesome-ava)
+- [AVA Casts](http://avacasts.com)
 
 ## Creato da
 
-[![Sindre Sorhus](https://avatars.githubusercontent.com/u/170270?s=130)](http://sindresorhus.com) | [![Kevin Mårtensson](https://avatars.githubusercontent.com/u/709159?s=130)](https://github.com/kevva) | [![Vadim Demedes](https://avatars.githubusercontent.com/u/697676?s=130)](https://github.com/vdemedes) | [![James Talmage](https://avatars.githubusercontent.com/u/4082216?s=130)](https://github.com/jamestalmage) | [![Mark Wubben](https://avatars.githubusercontent.com/u/33538?s=130)](https://novemberborn.net)
----|---|---|---|---
-[Sindre Sorhus](http://sindresorhus.com) | [Vadim Demedes](https://github.com/vdemedes) | [James Talmage](https://github.com/jamestalmage) | [Mark Wubben](https://novemberborn.net)
+[![Sindre Sorhus](https://avatars.githubusercontent.com/u/170270?s=130)](http://sindresorhus.com) | [![Vadim Demedes](https://avatars.githubusercontent.com/u/697676?s=130)](https://github.com/vadimdemedes) | [![James Talmage](https://avatars.githubusercontent.com/u/4082216?s=130)](https://github.com/jamestalmage) | [![Mark Wubben](https://avatars.githubusercontent.com/u/33538?s=130)](https://novemberborn.net) | [![Juan Soto](https://avatars.githubusercontent.com/u/8217766?s=130)](https://juansoto.me) | [![Jeroen Engels](https://avatars.githubusercontent.com/u/3869412?s=130)](https://github.com/jfmengels)
+---|---|---|---|---|---
+[Sindre Sorhus](http://sindresorhus.com) | [Vadim Demedes](https://github.com/vadimdemedes) | [James Talmage](https://github.com/jamestalmage) | [Mark Wubben](https://novemberborn.net) | [Juan Soto](http://juansoto.me) | [Jeroen Engels](https://github.com/jfmengels)
 
 ### Ex Membri
 
@@ -950,7 +1200,9 @@ La [galassia di Andromeda](https://it.wikipedia.org/wiki/Galassia_di_Andromeda).
 	<br>
 	<br>
 	<br>
-	<img src="https://cdn.rawgit.com/avajs/ava/fe1cea1ca3d2c8518c0cc39ec8be592beab90558/media/logo.svg" width="200" alt="AVA">
+    <a href="https://ava.li">
+	  <img src="https://cdn.rawgit.com/avajs/ava/fe1cea1ca3d2c8518c0cc39ec8be592beab90558/media/logo.svg" width="200" alt="AVA">
+    </a>
 	<br>
 	<br>
 </div>