Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Integrazione di Device Farm con un sistema di build Gradle
<a name="aws-device-farm-android-gradle-plugin"></a>

Il plugin Device Farm Gradle fornisce l'integrazione di AWS Device Farm con il sistema di build Gradle in Android Studio. Per ulteriori informazioni, consulta [Gradle](https://gradle.org).

**Nota**  
Per scaricare il plugin Gradle, vai a [GitHub](https://github.com/awslabs/aws-device-farm-gradle-plugin)e segui le istruzioni in. [Creazione del plugin Device Farm Gradle](#aws-device-farm-gradle-plugin-building)

Il plugin Device Farm Gradle fornisce la funzionalità Device Farm dal tuo ambiente Android Studio. Puoi iniziare i test su telefoni e tablet Android reali ospitati da Device Farm.

Questa sezione contiene una serie di procedure per configurare e utilizzare il Device Farm Gradle Plugin.

**Topics**
+ [Dipendenze](#aws-device-farm-gradle-plugin-dependencies)
+ [Fase 1: creazione del plug-in AWS Device Farm Gradle](#aws-device-farm-gradle-plugin-building)
+ [Fase 2: configurazione del plugin AWS Device Farm Gradle](#aws-device-farm-gradle-plugin-setting-up)
+ [Fase 3: Generazione di un utente IAM nel plugin Device Farm Gradle](#aws-device-farm-gradle-plugin-generating-iam-user)
+ [Fase 4: Configurazione dei tipi di test](#aws-device-farm-gradle-plugin-configuring-test-types)

## Dipendenze
<a name="aws-device-farm-gradle-plugin-dependencies"></a>

**Runtime**
+ Il Device Farm Gradle Plugin richiede AWS Mobile SDK 1.10.15 o successivo. Per ulteriori informazioni e per installare l'SDK, consulta [SDK AWS Mobile](https://aws.amazon.com/mobile/sdk/).
+ Android Tools Builder Test API 0.5.2
+ Apache Commons Lang3 3.3.4

**Per unit test**
+ Testng 6.8.8
+ Jmockit 1.19
+ Android Gradle Tools 1.3.0

## Fase 1: creazione del plug-in AWS Device Farm Gradle
<a name="aws-device-farm-gradle-plugin-building"></a>

Questo plugin fornisce l'integrazione di AWS Device Farm con il sistema di build Gradle in Android Studio. Per ulteriori informazioni, consulta [Gradle](https://gradle.org).

**Nota**  
La creazione del plugin è facoltativa. Il plugin viene pubblicato tramite Maven Central. Se desideri consentire a Gradle di scaricare direttamente il plugin, salta questa fase e passa a [Fase 2: configurazione del plugin AWS Device Farm Gradle](#aws-device-farm-gradle-plugin-setting-up).

**Per creare il plugin**

1. Vai al [GitHub](https://github.com/awslabs/aws-device-farm-gradle-plugin)repository e clona.

1. Creare il plugin usando `gradle install`.

   Il plugin viene installato sull'archivio Maven locale.

Fase successiva: [Fase 2: configurazione del plugin AWS Device Farm Gradle](#aws-device-farm-gradle-plugin-setting-up)

## Fase 2: configurazione del plugin AWS Device Farm Gradle
<a name="aws-device-farm-gradle-plugin-setting-up"></a>

Se non lo hai già fatto, clona l'archivio e installa il plugin usando la procedura indicata qui: [Creazione del plugin Device Farm Gradle](#aws-device-farm-gradle-plugin-building).

**Per configurare il plugin AWS Device Farm Gradle**

1. Aggiungere l'artefatto del plugin al proprio elenco di dipendenze in `build.gradle`.

   ```
       buildscript {
   
           repositories {        
               mavenLocal()            
               mavenCentral()            
           }
   
           dependencies {        
               classpath 'com.android.tools.build:gradle:1.3.0'           
               classpath 'com.amazonaws:aws-devicefarm-gradle-plugin:1.0'            
           }        
       }
   ```

1. Configurare il plugin nel proprio file `build.gradle`. La seguente configurazione della specifica di test deve fungere da guida:

   ```
   apply plugin: 'devicefarm'
   
   devicefarm {
   
       // Required. The project must already exist. You can create a project in the AWS Device Farm console.
       projectName "My Project" // required: Must already exist.
   
       // Optional. Defaults to "Top Devices"
       // devicePool "My Device Pool Name"
       
       // Optional. Default is 150 minutes
       // executionTimeoutMinutes 150
       
       // Optional. Set to "off" if you want to disable device video recording during a run. Default is "on"
       // videoRecording "on"
       
       // Optional. Set to "off" if you want to disable device performance monitoring during a run. Default is "on"
       // performanceMonitoring "on"
       
       // Optional. Add this if you have a subscription and want to use your unmetered slots
       // useUnmeteredDevices()
       
       // Required. You must specify either accessKey and secretKey OR roleArn. roleArn takes precedence. 
       authentication {
           accessKey "AKIAIOSFODNN7EXAMPLE"
           secretKey "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
           
           // OR
           
           roleArn "arn:aws:iam::111122223333:role/DeviceFarmRole"
       }
   
       // Optionally, you can 
       // - enable or disable Wi-Fi, Bluetooth, GPS, NFC radios
       // - set the GPS coordinates
       // - specify files and applications that must be on the device when your test runs
       devicestate {
           // Extra files to include on the device.
           // extraDataZipFile file("path/to/zip")
           
           // Other applications that must be installed in addition to yours. 
           // auxiliaryApps files(file("path/to/app"), file("path/to/app2"))
           
           // By default, Wi-Fi, Bluetooth, GPS, and NFC are turned on.
           // wifi "off"
           // bluetooth "off"
           // gps "off"
           // nfc "off"
           
           // You can specify GPS location. By default, this location is 47.6204, -122.3491
           // latitude 44.97005
           // longitude -93.28872
       }
    
       // By default, the Instrumentation test is used.
       // If you want to use a different test type, configure it here.
       // You can set only one test type (for example, Calabash, Fuzz, and so on)
    
       // Fuzz
       // fuzz { }
   
       // Calabash
       // calabash { tests file("path-to-features.zip") }
          
   }
   ```

1. Esegui il test di Device Farm utilizzando la seguente attività:`gradle devicefarmUpload`.

   L'output della build stamperà un collegamento alla console Device Farm dove è possibile monitorare l'esecuzione del test.

Fase successiva: [Generazione di un utente IAM nel plugin Device Farm Gradle](#aws-device-farm-gradle-plugin-generating-iam-user)

## Fase 3: Generazione di un utente IAM nel plugin Device Farm Gradle
<a name="aws-device-farm-gradle-plugin-generating-iam-user"></a>

AWS Identity and Access Management (IAM) ti aiuta a gestire le autorizzazioni e le politiche per lavorare con AWS le risorse. Questo argomento illustra come generare un utente IAM con autorizzazioni per accedere alle risorse di AWS Device Farm.

Se non l'hai già fatto, completa i passaggi 1 e 2 prima di generare un utente IAM.

Si consiglia di non utilizzare l'account AWS root per accedere a Device Farm. Invece, crea un nuovo utente IAM (o utilizza un utente IAM esistente) nel tuo AWS account, quindi accedi a Device Farm con quell'utente IAM.

**Nota**  
L'account AWS root o l'utente IAM che utilizzi per completare i seguenti passaggi deve disporre dell'autorizzazione per creare la seguente policy IAM e collegarla all'utente IAM. Per ulteriori informazioni, consulta l'articolo relativo all'[utilizzo delle policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/policies_manage.html).

**Per creare un nuovo utente con la politica di accesso appropriata in IAM**

1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Scegliere **Users (Utenti)**.

1. Scegliere **Create New Users (Crea nuovi utenti)**.

1. Immettere il nome utente di propria scelta.

   Ad esempio, **GradleUser**.

1. Scegli **Create** (Crea).

1. Scegliere **Download Credentials (Scarica credenziali)** e salvarle in una posizione in cui saranno facilmente recuperabili in seguito.

1. Scegli **Chiudi**.

1. Selezionare il nome utente nell'elenco.

1. In **Permissions (Autorizzazioni)**, espandere l'intestazione **Inline Policies (Policy inline)** facendo clic sulla freccia giù a destra.

1. Scegli **Fai clic qui** dove dice, **Non ci sono politiche in linea da mostrare. Per crearne uno, clicca qui**.

1. Sulla schermata **Set Permissions (Imposta autorizzazioni)**, selezionare **Custom Policy (Personalizza policy)**.

1. Scegli **Seleziona**.

1. Assegnare un nome alla policy, ad esempio **AWSDeviceFarmGradlePolicy**.

1. Incollare la seguente policy in **Policy Document (Documento policy)**.

------
#### [ JSON ]

****  

   ```
       {
           "Version":"2012-10-17",		 	 	 
           "Statement": [
               {
                   "Sid": "DeviceFarmAll",
                   "Effect": "Allow",
                   "Action": [ "devicefarm:*" ],
                   "Resource": [ "*" ]
               }
           ]
       }
   ```

------

1. Scegli **Apply Policy** (Applica policy).

Fase successiva: [Configurazione dei tipi di test](#aws-device-farm-gradle-plugin-configuring-test-types).

Per ulteriori informazioni, consulta [Creazione di un utente IAM (Console di gestione AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_SettingUpUser.html#Using_CreateUser_console) o[Configurazione](setting-up.md).

## Fase 4: Configurazione dei tipi di test
<a name="aws-device-farm-gradle-plugin-configuring-test-types"></a>

Per impostazione predefinita, il plug-in AWS Device Farm Gradle esegue il [Strumentazione per Android e AWS Device Farm](test-types-android-instrumentation.md) test. Se desideri eseguire i tuoi test o specificare parametri aggiuntivi, puoi scegliere di configurare un tipo di test. Questo argomento fornisce informazioni su ciascun tipo di test disponibile e su ciò che devi fare in Android Studio per configurarlo per l'uso. Per ulteriori informazioni sui tipi di test disponibili in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md).

Se non l'hai già fatto, completa i passaggi da 1 a 3 prima di configurare i tipi di test.

**Nota**  
Se stai utilizzando [slot per i dispositivi](how-to-purchase-device-slots.md), la loro funzionalità sarà disabilitata per impostazione predefinita.

### Appium
<a name="configuring-test-types-appium"></a>

Device Farm fornisce supporto per Appium Java e JUnit TestNG per Android.
+ [Appium (in Java ()) JUnit](https://docs.aws.amazon.com//devicefarm/latest/developerguide/test-types-appium.html)
+ [Appium (in Java (TestNg))](https://docs.aws.amazon.com//devicefarm/latest/developerguide/test-types-appium.html)

Puoi scegliere `useTestNG()` o `useJUnit()`. `JUnit` è l'impostazione predefinita e non deve essere specificata in modo esplicito.

```
    appium {
        tests file("path to zip file") // required
        useTestNG() // or useJUnit()
    }
```

### Incorporato: fuzz
<a name="configuring-test-types-built-in-fuzz"></a>

Device Farm offre un tipo di fuzz test integrato, che invia in modo casuale gli eventi dell'interfaccia utente ai dispositivi e quindi riporta i risultati.

```
    fuzz {

       eventThrottle 50 // optional default
       eventCount 6000  // optional default
       randomizerSeed 1234 // optional default blank

     }
```

Per ulteriori informazioni, consulta [Esecuzione del fuzz test integrato di Device Farm (Android e iOS)](test-types-built-in-fuzz.md).

### Instrumentation
<a name="configuring-test-types-instrumentation"></a>

Device Farm fornisce supporto per la strumentazione (EspressoJUnit, Robotium o qualsiasi test basato sulla strumentazione) per Android. Per ulteriori informazioni, consulta [Strumentazione per Android e AWS Device Farm](test-types-android-instrumentation.md).

Quando si esegue un test di strumentazione in Gradle, Device Farm utilizza il `.apk` file generato dalla directory **AndroidTest** come fonte dei test.

```
    instrumentation { 

        filter "test filter per developer docs" // optional

    }
```