Getting started - sbt track - italian translations

_it/getting-started/sbt-track/getting-started-with-scala-and-sbt-on-the-command-line.md

@@ -0,0 +1,79 @@
+---
+title: Primi passi su scala e sbt con la linea di comando
+layout: singlepage-overview
+partof: getting-started-with-scala-and-sbt-on-the-command-line
+language: it
+disqus: true
+next-page: /it/testing-scala-with-sbt-on-the-command-line
+---
+
+In questo tutorial si vedrà come creare un progetto Scala a partire da un template, che può essere usato come punto di partenza anche per progettti personali. 
+Lo strumento utilizzato per tale scopo è [sbt](https://www.scala-sbt.org/1.x/docs/index.html), che è lo standard di build per Scala.
+sbt permette di compilare, eseguire e testare i tuoi progetti, ma permette di svolgere anche altri compiti.
+Si presuppone una conoscenza dell'uso della linea di comando.
+
+## Installazione
+1. Assicurarsi di avere la Java 8 JDK (conosciuta anche come 1.8) installata
+    * Per verificarlo, eseguire `javac -version` da linea di comando e controllare che nell'output sia riportato
+    `javac 1.8.___`
+    * Se non si possiede la versione 1.8 o superiore, installarla seguendo [queste indicazioni](https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)
+1. Installare sbt
+    * [Mac](https://www.scala-sbt.org/1.x/docs/Installing-sbt-on-Mac.html)
+    * [Windows](https://www.scala-sbt.org/1.x/docs/Installing-sbt-on-Windows.html)
+    * [Linux](https://www.scala-sbt.org/1.x/docs/Installing-sbt-on-Linux.html)
+
+## Creare il progetto
+1. Eseguire il comando `cd` specificando una cartella vuota per spostarsi in essa.
+1. Eseguire il comando `sbt new scala/hello-world.g8`. Questo effettuerà una pull del template 'hello-world' da GitHub.
+    Si occuperà inoltre di creare la cartella `target`, che per ora può essere ignorata. 
+1. Quando richiesto verrà richiesto il nome dell'applicazione, indicare `hello-world`. In questo modo verrà creato un progetto chiamato "hello-world".
+1. Osserviamo cosa è stato generato una volta eseguiti i passaggi sopra riportati:
+
+```
+- hello-world
+    - project (sbt usa questa cartella per installare e gestire plugins e dipendenze)
+        - build.properties
+    - src
+        - main
+            - scala (Tutto il codice scala che viene scritto dovrà andare qui)
+                - Main.scala (Entry point dell'applicazione) <-- per ora è tutto ciò che ci servirà
+    - build.sbt (il file di definizione della build interpretato da sbt)
+```
+
+Una volta che verrà buildato il progetto, sbt creerà diverse cartelle `target` per i file generati. Possono essere ignorate per lo scopo di questo tutorial.
+
+## Eseguire il progetto
+1. `cd` nella cartella `hello-world`.
+1. Lanciare il comando `sbt`. Questo aprirà la console di sbt.
+1. Eseguire `~run`. Il carattere `~` è opzionale. Indica ad sbt di eseguirsi ad ogni salvataggio di un file, permettendo un ciclo di modifica, esecuzione e debug più veloce. sbt genererà anche una cartella chiamata `target` che può essere ignorata.
+
+## Modificare il codice
+1. Aprire il file `src/main/scala/Main.scala` in un qualsiasi editor di testo.
+1. Modificare "Hello, World!" in "Hello, New York!"
+1. Se non è stato interrotto il comando sbt, dovrebbe ora apparire "Hello, New York!" sulla console.
+1. Si può continuare a modificare il file, e le modifiche dovrebbero apparire a schermo se non vengono riportati errori. 
+
+## Aggiungere una dipendenza
+Vediamo ora come utilizzare librerie pubblicate da terzi per aggiungere ulteriori funzionalità alle nostre applicazioni.
+
+1. Aprire il file `build.sbt` con un qualsiasi editor di testo e aggiungere la seguente riga:
+
+```
+libraryDependencies += "org.scala-lang.modules" %% "scala-parser-combinators" % "1.1.2"
+```
+`libraryDependencies` è un set (un tipo di collection in scala), e utilizzando il simbolo `+=`,
+si sta aggiungendo la dipendenza [scala-parser-combinators](https://github.com/scala/scala-parser-combinators) al set di dipendenze che sbt fetcherà quando verà inizializzato.
+Una volta eseguito questo passaggio, sarà possibile importare classi, object ed altro da scala-parser-combinators tramite una semplice istruzione di import.
+
+Ulteriori librerie pubblicate possono essere trovate sul sito
+[Scaladex](https://index.scala-lang.org/), dove è possibile copiare le informazioni delle dipendenze cercate nel file `build.sbt`.
+
+## Next steps
+
+Si consiglia di continuare al tutorial successivo della serie  _getting started with sbt_ , ed imparare a [testare il codice Scala con sbt tramite linea di comando](testing-scala-with-sbt-on-the-command-line.html).
+
+**oppure**
+
+- Continuare ad imparare Scala online e in maniera interattiva su
+ [Scala Exercises](https://www.scala-exercises.org/scala_tutorial).
+- Imparare le feature di Scala tramite articoli più concisi su [Tour of Scala]({{ site.baseurl }}/tour/tour-of-scala.html).

_it/getting-started/sbt-track/testing-scala-with-sbt-on-the-command-line.md

@@ -0,0 +1,101 @@
+---
+title: Testare scala con sbt da linea di comando 
+layout: singlepage-overview
+partof: testing-scala-with-sbt-on-the-command-line
+language: it
+disqus: true
+previous-page: /it/getting-started-with-scala-and-sbt-on-the-command-line
+---
+
+Ci sono diverse librerie e modalità per testare il codice Scala, ma in questo tutorial verrà mostrato come eseguire il testing usando [AnyFunSuite](https://www.scalatest.org/scaladoc/3.2.2/org/scalatest/funsuite/AnyFunSuite.html) del framework ScalaTest.
+Si assume che si sappia [creare un progetto Scala con sbt](getting-started-with-scala-and-sbt-on-the-command-line.html).
+
+## Setup
+1. Da linea di comando, creare una nuova directory in una posizione a propria scelta.
+1. `cd` nella cartella appena creata ed eseguire `sbt new scala/scalatest-example.g8`
+1. Quando richiesto, rinominare il progetto come `ScalaTestTutorial`.
+1. Il progetto avrà già in se la libreria ScalaTest come dipendenza indicata nel file `build.sbt`.
+1. `cd` nel progetto ed eseguire `sbt test`. Questo eseguirà la test suite
+`CubeCalculatorTest` con un unico test chiamato `CubeCalculator.cube`.
+
+```
+sbt test
+[info] Loading global plugins from /Users/username/.sbt/0.13/plugins
+[info] Loading project definition from /Users/username/workspace/sandbox/my-something-project/project
+[info] Set current project to scalatest-example (in build file:/Users/username/workspace/sandbox/my-something-project/)
+[info] CubeCalculatorTest:
+[info] - CubeCalculator.cube
+[info] Run completed in 267 milliseconds.
+[info] Total number of tests run: 1
+[info] Suites: completed 1, aborted 0
+[info] Tests: succeeded 1, failed 0, canceled 0, ignored 0, pending 0
+[info] All tests passed.
+[success] Total time: 1 s, completed Feb 2, 2017 7:37:31 PM
+```
+
+## Comprendere i test
+1. In qualsiasi editor di testo aprire i seguenti due file: 
+    * `src/main/scala/CubeCalculator.scala`
+    * `src/test/scala/CubeCalculatorTest.scala`
+1. Nel file `CubeCalculator.scala`, è riportata la definizione della funzione `cube`.
+1. Nel file `CubeCalculatorTest.scala`, è presente una classe chiamata allo stesso modo dell'oggetto che stiamo testando.
+
+```
+  import org.scalatest.funsuite.AnyFunSuite
+
+  class CubeCalculatorTest extends AnyFunSuite {
+      test("CubeCalculator.cube") {
+          assert(CubeCalculator.cube(3) === 27)
+      }
+  }
+```
+
+Analizziamo ogni riga di codice.
+
+* `class CubeCalculatorTest` significa che stiamo testando l'oggetto `CubeCalculator`
+* `extends AnyFunSuite` ci permette di utilizzare la funzionalità della classe AnyFunSuite, come ad esempio la funzione `test`
+* `test` è una funzione proveniente da AnyFunSuite che raccoglie i risultati delle asserzioni all'interno del corpo della funzione.
+* `"CubeCalculator.cube"` è il nome del test. Può essere chiamato in qualsiasi modo, ma la convenzione è "NomeClasse.nomeMetodo".
+* `assert` prende una condizione booleana e stabilisce se il test è superato o no.
+* `CubeCalculator.cube(3) === 27` controlla se l'output della funzione `cube` sia realmente 27.
+Il simbolo `===` è parte di ScalaTest e restituisce messaggi di errore comprensibili.
+
+## Aggiungere un altro test case
+1. Aggiungere un altro blocco di testo contenente il proprio enunciato `assert` che verificherà il cubo di `0`.
+
+    ```
+      import org.scalatest.funsuite.AnyFunSuite
+
+      class CubeCalculatorTest extends AnyFunSuite {
+          test("CubeCalculator.cube 3 should be 27") {
+              assert(CubeCalculator.cube(3) === 27)
+          }
+
+          test("CubeCalculator.cube 0 should be 0") {
+              assert(CubeCalculator.cube(0) === 0)
+          }
+      }
+    ```
+
+1. Lanciare `sbt test` nuovamente e controllare i risultati.
+
+    ```
+    sbt test
+    [info] Loading project definition from C:\projects\scalaPlayground\scalatestpractice\project
+    [info] Loading settings for project root from build.sbt ...
+    [info] Set current project to scalatest-example (in build file:/C:/projects/scalaPlayground/scalatestpractice/)
+    [info] Compiling 1 Scala source to C:\projects\scalaPlayground\scalatestpractice\target\scala-2.13\test-classes ...
+    [info] CubeCalculatorTest:
+    [info] - CubeCalculator.cube 3 should be 27
+    [info] - CubeCalculator.cube 0 should be 0
+    [info] Run completed in 257 milliseconds.
+    [info] Total number of tests run: 2
+    [info] Suites: completed 1, aborted 0
+    [info] Tests: succeeded 2, failed 0, canceled 0, ignored 0, pending 0
+    [info] All tests passed.
+    [success] Total time: 3 s, completed Dec 4, 2019 10:34:04 PM
+    ```
+
+## Conclusioni
+In questo tutorial è stato mostrato una delle modalità per testare il codice Scala. Per saperne di più su FunSuite si può consultare [il sito ufficiale](https://www.scalatest.org/getting_started_with_fun_suite). 
+Si possono anche consultare altri framework di testing come [ScalaCheck](https://www.scalacheck.org/) e [Specs2](https://etorreborre.github.io/specs2/).