[IT] Fixing translations + adding lesson 11

it/11/00-overview.md

@@ -0,0 +1,28 @@
+---
+title: Testare Smart Contracts con Truffle
+header: Testare Smart Contracts con Truffle
+roadmap: roadmap.jpg
+path: solidity_advanced
+position: 1
+publishedOn: Cryptozombies
+---
+
+Benvenuto! Completando le lezioni precedenti hai dimostrato hai le competenze necessarie per proseguite.
+
+Quindi andiamo avanti e rilasciamo il gioco sulla Mainnet. Goditi il successo!
+
+Prenditi un attimo...ci sono _alcune cose_ che potrebbero esserti già venute in mente. Dopo tutto, una volta che i contratti vengono rilasciare sulla mainnet, restanno lì per sempre. Se sono presenti degli errori, resteranno anche loro lì per sempre. Come zombie immortali.
+
+Errori o _**bugs**_ succedono a tutti gli sviluppatori, non importa quante competenze hai. Non vorresti dare il 100% di chance di vittoria ad uno zombie che effettua un attacco, ma può succedere.
+
+Chiaramento dare all'attaccante il 100% di possibilità di vittoria vorrebbe dire che non è più un gioco, o comunque non è più divertente. Un bug come questo distruggerebbe il tuo gioco e non ci sarebbe nulla da fare per i tuoi zombie.
+
+Per impedire che questa cosa terribile accada, è essenziale testare a fondo ogni aspetto del gioco.
+
+Alla fine della lezione sarai in grado di:
+
+- Testare i tuoi smart contracts con `Truffle` contro `Ganache`
+- Usare `Chai` per scrivere affermazioni più espressive
+- Testare `Loom`😉
+
+Iniziamo!

it/11/01.md

@@ -0,0 +1,64 @@
+---
+title: Introduzione
+actions: ['checkAnswer', 'hints']
+requireLogin: true
+skipCheckAnswer: false
+material:
+  terminal:
+    help: Probabilmente dovresti lanciare il comando `touch test/CryptoZombies.js`😉
+    commands:
+      'touch test/CryptoZombies.js':
+        hint: touch test/CryptoZombies.js
+        output: |
+---
+
+In questa lezione, vedremo la teoria dietro il testing degli Smart Contracts di **Etherium**, concentrandoci su **Truffle**, **Mocha**, e **Chai**. Avrai bisogno di un livello intermedio di conoscenza di **Solidity** e **JavaScript** per riuscire a completare la maggior parte delle lezioni.
+
+Se non conosci **Solidity**, o vuoi ripassare alcuni concetti, iniziare a imparare con la nostra <a href="https://cryptozombies.io/lesson/1" target=_blank>prima lezione</a>.
+
+Se non conosci **JavaScript**, considera la possibilità di seguire dei tutorial relativi ad esso prima di iniziare questa lezione.
+
+## Diamo un'occhiata al nostro progetto
+
+Se hai seguito le nostre precedenti lezioni, avresti dovuto costruire un gioco a tema zombi che è in gran parte pronto e la struttura dei tuoi file dovrebbe assomigliare a questa:
+
+```
+├── build
+  ├── contracts
+      ├── Migrations.json
+      ├── CryptoZombies.json
+      ├── erc721.json
+      ├── ownable.json
+      ├── safemath.json
+      ├── zombieattack.json
+      ├── zombiefactory.json
+      ├── zombiefeeding.json
+      ├── zombiehelper.json
+      ├── zombieownership.json
+├── contracts
+  ├── Migrations.sol
+  ├── CryptoZombies.sol
+  ├── erc721.sol
+  ├── ownable.sol
+  ├── safemath.sol
+  ├── zombieattack.sol
+  ├── zombiefactory.sol
+  ├── zombiefeeding.sol
+  ├── zombiehelper.sol
+  ├── zombieownership.sol
+├── migrations
+└── test
+. package-lock.json
+. truffle-config.js
+. truffle.js
+```
+
+Hai notato la cartella `test`? Questa è la cartella dove inseriremo i nostri test.
+
+_Truffle_ offre supporto per test scritti in _JavaScript_ e _Solidity_ ma, per questa lezione, manteremmo le cose semplici e utilizzeremo _JavaScript_.
+
+# Mettiamoci alla prova
+
+È buona norma creare un file di prova separato per ogni contratto e assegnargli il nome del contratto intelligente. Ciò semplifica la gestione dei test a lungo termine, soprattutto quando il progetto cresce e cambia.
+
+1. Nel terminale a destra, lancia il comando `touch test/CryptoZombies.js`.

it/11/02.md

@@ -0,0 +1,77 @@
+---
+title: Introduzione (continua)
+actions: ['checkAnswer', 'hints']
+requireLogin: true
+material:
+  editor:
+    language: javascript
+    startingCode:
+      'test/CryptoZombies.js': |
+    risposta: >
+      const CryptoZombies = artifacts.require("CryptoZombies");
+
+      contract("CryptoZombies", (accounts) => {
+          it("should be able to create a new zombie", () => {
+
+          })
+      })
+---
+
+Andiamo avanti. in questo capitolo continuiamo con le impostazioni per scrivere e lanciare i nostri test.
+
+## Build Artifacts
+
+Ogni volta che si compila uno smart contract, il compilatore _Solidity_ genera un file JSON (denominato **build artefacts**) che contiene la rappresentazione binaria di quel contratto e lo salva nella cartella `build/contracts`.
+
+Successivamente, quando esegui una migrazione, _Truffle_ aggiorna questo file con le informazioni relative a quella rete.
+
+La prima cosa che devi fare ogni volta che inizi a scrivere una nuova suite di test è caricare gli artifacts di build del contratto con cui vuoi interagire. In questo modo, **Truffle** saprà come formattare le nostre chiamate di funzione in un modo comprensibile per il contratto.
+
+Vediamo subito un semplice esempio.
+
+Supponiamo che esistesse un contratto chiamato "MyAwesomeContract". Potremmo fare qualcosa del genere per caricare gli artifacts della build:
+
+```javascript
+const MyAwesomeContract = artifacts.require(“MyAwesomeContract”);
+```
+
+The function returns something called a **_contract abstraction_**. In a nutshell, a _contract abstraction_ hides the complexity of interacting with **Ethereum** and provides a convenient _JavaScript_ interface to our _Solidity_ smart contract. We'll be using it in the next chapters.
+
+La funzione restituisce qualcosa chiamato **_contract abstraction_**. In poche parole, una \__contract abstraction_ nasconde la complessità dell'interazione con **Ethereum** e fornisce una comoda interfaccia _JavaScript_ per il nostro smart contract in _Solidity_. Lo useremo nei prossimi capitoli.
+
+### La funzione contract()
+
+**Truffle** aggiunge un sottile involucro intorno alla **Mocha** per semplificare i test. Poiché il nostro corso si concentra sullo sviluppo di **Ethereum**, non entreremo nel troppo dettaglio su _Mocha_. Se vuoi saperne di più riguardo _Mocha_, vai sul <a href="https://mochajs.org/" target=_blank>loro sito ufficiale</a> una volta che avrai terminato questa lezione. Per adesso devi solo capire cosa impararemo qui - Come fare:
+
+- **Test di gruppo** utilizzando la funzione `contract()`. Questa funzione estende la funzione `describe()` di **Mocha** fornendo una **lista di account per i test** e mantendo un po' di pulizia.
+
+  `contract()` prende due argomenti. Il primo, una `string`, deve indicare cosa testeremo. Il secondo parametro, un `callback`, è dove scriveremo effettivamente i nostri test.
+
+- **Eseguimaoli**: il modo in cui lo faremo è chiamare una funzione chiamata `it()` che accetta anche due argomenti: una `string` che descrive cosa fa effettivamente il test e un `callback`.
+
+Mettendolo tutto questo insieme, ecco un semplice test:
+
+```javascript
+contract('MyAwesomeContract', (accounts) => {
+	it('should be able to receive Ethers', () => {});
+});
+```
+
+> Nota: un test scritto bene spiega cosa fa effettivamente il codice. Assicurati che la descrizione della suite di test e il test case possano essere letti insieme come una **affermazione coerente**. Pensa come se stessi scrivendo della documentazione relativa al tuo codice.
+
+Ogni test che scriverai dovrà seguire questo schema. Sembra facile, non è vero?😁
+
+# Mettiti alla prova
+
+Ora che abbiamo creato un file `CryptoZombies.js` vuoto, è il momento di riempirlo.
+
+1. La prima riga di codice dovrebbe dichiarare un `const` chiamato `CryptoZombies` e impostarlo uguale al risultato della funzione `artifacts.require` con il nome del contratto che vogliamo testare come argomento.
+
+2. Quindi, vai avanti e copia/incolla il test qui in alto.
+3. Cambia il modo in cui chiamiamo `contract()` in modo tale che il primo parametro sia il nome del nostro smart contract.
+
+   > Nota: non preoccuparti dell'argomento `accounts`. Lo spiegheremo nel prossimo capitolo.
+
+4. Il primo parametro passato alla funzione `it()` (nel nostro esempio, cioè "should be able to receive Ether") dovrebbe essere il nome del nostro test. Dal momento che il nostro scopo è scrivere un test per la creazione di un nuovo zombi, assicurati che il primo parametro sia impostato su "should be able to create a new zombie".
+
+Abbiamo impostato la base. Andiamo al prossimo capitolo!

it/11/03.md

@@ -0,0 +1,70 @@
+---
+title: Il primo test - Creazione di uno zombie
+actions: ['checkAnswer', 'hints']
+requireLogin: true
+material:
+  editor:
+    language: javascript
+    startingCode:
+      'test/CryptoZombies.js': |
+        const CryptoZombies = artifacts.require("CryptoZombies");
+        contract("CryptoZombies", (accounts) => {
+            //1. initialize `alice` and `bob`
+            it("should be able to create a new zombie", () => { //2. Make the callback async
+            })
+        })
+
+    answer: >
+      const CryptoZombies = artifacts.require("CryptoZombies");
+
+      contract("CryptoZombies", (accounts) => {
+          let [alice, bob] = accounts;
+          it("should be able to create a new zombie", async () => {
+          })
+      })
+---
+
+Prima di rilasciare il tuo codice su **Ethereum**, è meglio testare i tuoi smart contract in locale.
+
+Puoi farlo utilizzando uno strumento chiamato <a href="https://truffleframework.com/ganache" target=_blank>Ganache</a>, che installa un network **Ethereum** in locale.
+
+Ogni volta che _Ganache_ viene avviato, crea 10 account di prova e fornisce loro 100 Ether per semplificare i test. Poiché _Ganache_ e _Truffle_ sono strettamente integrati, possiamo accedere a questi account attraverso l'array `accounts` che abbiamo menzionato nel capitolo precedente.
+
+Ma usare `accounts[0]` e `accounts[1]` non renderebbe i nostri testi facilmente leggibili, giusto?
+
+Per facilitare la comprensione, utilizzeremo dei placeholder: Alice e Bob. Quindi, all'interno della funzione `contract()`, inizializziamoli in questo modo:
+
+```javascript
+let [alice, bob] = accounts;
+```
+
+> Nota: perdona la scarsa grammatica. In _JavaScript_, la convenzione prevede l'utilizzo di lettere minuscole per i nomi delle variabili.
+
+Perché Alice e Bob? C'è una grande tradizione che rende "Alice e Bob" o più brevemente "A e B" ampiamente utilizzati in crittografia, fisica, programmazione e altro ancora. È una storia breve ma interessante, e vale la pena <a href="http://cryptocouple.com/" target=_blank>leggere</a> dopo il completamento di questa lezione.
+
+Ora facciamo il nostro primo test.
+
+## Creazione di un nuovo Zombie
+
+Supponiamo che Alice voglia giocare al nostro fantastico gioco. Se è così, la prima cosa che vorrebbe fare è **creare il proprio zombi 🧟**. Per farlo, il front-end (o _Truffle_ nel nostro caso) dovrebbe chiamare la funzione `createRandomZombie`.
+
+> Nota: per rifrescare la memoria riportiamo il codice _Solidity_ nel nostro contratto:
+
+```sol
+function createRandomZombie(string _name) public {
+  require(ownerZombieCount[msg.sender] == 0);
+  uint randDna = _generateRandomDna(_name);
+  randDna = randDna - randDna % 100;
+  _createZombie(_name, randDna);
+}
+```
+
+Iniziamo testando questa funzione
+
+# Testiamo
+
+1.  La prima riga della funzione `contract()` dovrebbe dichiarare due variabili chiamate `alice` e `bob` e inizializzarle come mostrato sopra.
+
+2.  Successivamente, vorremmo chiamare correttamente la funzione `it()`. Il secondo parametro (una funzione di `callback`) "parlerà" con la blockchain, per questo doremo renderla asincrona. Basta anteporre la parola chiave `async`. In questo modo, ogni volta che questa funzione viene chiamata con la parola chiave `await`, il nostro test attende una risposta prima di procedere.
+
+> Il funzionamento delle promises non è tra gli scopi di questa lezione. Una volta terminata questa lezione, dai un'occhiata alla <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" target=_blank>documentazione ufficiale </a> per approfondire l'argomento.

it/11/04.md

@@ -0,0 +1,76 @@
+---
+title: Il primo test - Creazione di uno zombie (continua)
+actions: ['checkAnswer', 'hints']
+requireLogin: true
+material:
+  editor:
+    language: javascript
+    startingCode:
+      'test/CryptoZombies.js': |
+        const CryptoZombies = artifacts.require("CryptoZombies");
+        const zombieNames = ["Zombie 1", "Zombie 2"];
+        contract("CryptoZombies", (accounts) => {
+            let [alice, bob] = accounts;
+            it("should be able to create a new zombie", async () => {
+                // start here
+            })
+        })
+
+    answer: >
+      const CryptoZombies = artifacts.require("CryptoZombies");
+
+      const zombieNames = ["Zombie 1", "Zombie 2"];
+
+      contract("CryptoZombies", (accounts) => {
+          let [alice, bob] = accounts;
+          it("should be able to create a new zombie", async () => {
+              const contractInstance = await CryptoZombies.new();
+          })
+      })
+---
+
+Ottimo lavoro! Ora che abbiamo una shell per il nostro primo test, lascia che ti spieghi come funziona.
+
+Solitamente, ogni test ha le seguenti fasi:
+
+1.  **_set up_**: in cui definiamo lo stato iniziale e inizializziamo gli input.
+
+2.  **_act_**: dove testiamo effettivamente il codice. Assicurati sempre di _testare solo una cosa_.
+
+3.  **_assert_:** dove controlliamo i risultati.
+
+Diamo un'occhiata a cosa dovrebbe fare il nostro test in modo più dettagliato.
+
+## 1. Impostazione
+
+Nel Capitolo 2, hai imparato a creare una _contract abstraction_. Tuttavia, una \__contract abstraction_, come dice il nome, è solo un'astrazione. Per interagire effettivamente con il smart contract, dobbiamo creare un oggetto _JavaScript_ che fungerà da **istanza** del contratto. Continuando il nostro esempio con `MyAwesomeContract`, possiamo usare la _contract abstraction_ per inizializzare la nostra istanza in questo modo:
+
+```javascript
+const contractInstance = await MyAwesomeContract.new();
+```
+
+Bene, allora come andiamo avanti?
+
+Chiamare `createRandomZombie` richiede di passargli il nome dello zombi come parametro. Quindi, il passo successivo sarebbe dare un nome allo zombi di Alice. Qualcosa come "Alice's Awesome Zombie".
+
+Tuttavia, se lo facciamo per ogni test, il nostro codice non avrà un bell'aspetto. Un approccio migliore consiste nell'inizializzazione di un array globale come segue:
+
+```javascript
+const zombieNames = ['Zombie #1', 'Zombie #2'];
+```
+
+E poi, chiamare i metodi del contratto in questo modo:
+
+```javascript
+contractInstance.createRandomZombie(zombieNames[0]);
+```
+
+> Nota: l'uso di un array per memorizzare i nomi degli zombi è utile se vuoi, ad esempio, scrivere un test che crei 1000 zombi invece di uno o due😉.
+
+# Testiamo
+
+Siamo andati avanti e abbiamo inizializzato l'array `zombieNames` per te.
+
+1. Creiamo un'istanza del nostro contratto. Dichiara un nuovo `const` chiamato `contractInstance` e impostalo uguale al risultato della funzione `CryptoZombies.new()`.
+
+2. `CryptoZombies.new()` comunica con la blockchain. Ciò significa che deve essere una funzione asincrona. Aggiungiamo la parola chiave `await` prima della chiamata di funzione.