Esercizio - Creare ed eseguire test personalizzati con il toolkit di test

  • 5 minuti

Come membro di un team responsabile di prodotto, è importante essere in grado di implementare alcune regole specifiche del team o del dominio. A tale scopo, è possibile implementare le regole come test e quindi eseguire i test usando il toolkit di test.

Creare ed eseguire un test personalizzato

Si creerà un test personalizzato e si userà lo strumento del toolkit di test per eseguirlo. Si correggerà anche il modello di distribuzione per assicurarsi che il test venga superato. Il test personalizzato verificherà che tutti i parametri seguano una regola di denominazione. Questa regola è un requisito specifico del dominio del team responsabile di prodotto di cui si è membri.

Per eseguire questo esercizio è consigliabile tenere aperti due editor di testo:

  • Creare un test personalizzato. Individuare il percorso della sottodirectory arm-ttk/testcases/deploymentTemplate/ della directory di installazione del toolkit di test. Da questa sottodirectory verrà eseguito Visual Studio Code in cui verrà creato e modificato un test personalizzato.
  • Creare un file modello ed eseguire i test. Selezionare la posizione desiderata per il percorso. È consigliabile avviare un'istanza di Visual Studio Code da questo percorso in modo da poter modificare facilmente il file azuredeploy.json quando richiesto. Avviare un terminale integrato con questa istanza di Visual Studio Code per semplificare l'esecuzione dei test.

Creare il file di modello

Scegliere una directory e creare un file denominato azuredeploy.json.

Avviso

Verificare che la directory selezionata sia vuota, senza sottodirectory.

Aggiungere il contenuto seguente:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {},
  "resources": []
}

Creare il test personalizzato

  1. Aprire Visual Studio Code e passare alla directory di installazione del toolkit di test. Posizionarsi nella sottodirectory arm-ttk/testcases/deploymentTemplate. Eseguire il comando riportato di seguito:

    code .

    Nota

    Se Visual Studio Code non è nel percorso, aprire Visual Studio Code manualmente e aprire la directory.

  2. Creare un file di test personalizzato denominato Custom-ParameterNaming.test.ps1. Inserire nel file il contenuto seguente:

    param(
[Parameter(Mandatory=$false,Position=0)] #not mandatory for case of an empty resource array
[PSObject]
$MainTemplateResources
)

Write-Error "To be implemented"

    Lasciare aperto l'editor di testo. Questo file verrà modificato in un secondo momento.

Eseguire il test personalizzato

Eseguire il test personalizzato seguendo questa procedura:

  1. Aprire una nuova finestra del terminale o riutilizzare quella precedente.

  2. Passare alla directory in cui è stato creato il file azuredeploy.json. Eseguire il comando seguente per avviare Visual Studio Code:

    code .

    Nota

    Se Visual Studio Code non è nel percorso, aprire Visual Studio Code manualmente e aprire la directory del modello.

  3. Da Visual Studio Code aprire il terminale integrato selezionando Terminale>Nuovo terminale nel menu principale. Eseguire il comando seguente nel terminale per avviare una shell di PowerShell:

    pwsh

    Verrà visualizzato un output simile al seguente:

    PowerShell 7.0.3
Copyright (c) Microsoft Corporation. All rights reserved.

https://aka.ms/powershell
Type 'help' to get help.

  4. Eseguire Import-Module nel terminale.

    Nota

    Prima di importare il modulo, sostituire path/to/arm-ttk/arm-ttk.psd1 con il percorso del toolkit di test scaricato.

    Import-Module path/to/arm-ttk/arm-ttk.psd1

    Suggerimento

    Se lo strumento è stato scaricato o clonato nella directory Download, il percorso dovrebbe essere simile a /Users/<user>/Downloads/arm-ttk/arm-ttk/arm-ttk.psd1.

    A questo punto è possibile iniziare a usare lo strumento. Se si rimane nella stessa sessione di PowerShell, non è necessario eseguire di nuovo il comando di importazione.

  5. Eseguire Test-AzTemplate nel terminale per avviare un'esecuzione dei test:

    Test-AzTemplate -TemplatePath .

    L'output è simile al seguente. Il test è indicato dalle righe evidenziate:

    Validating custom\azuredeploy.json
  JSONFiles Should Be Valid
    [+] JSONFiles Should Be Valid (56 ms)
Pass  : 1
Fail  : 0
Total : 1



  adminUsername Should Not Be A Literal
    [+] adminUsername Should Not Be A Literal (68 ms)
  apiVersions Should Be Recent In Reference Functions
    [+] apiVersions Should Be Recent In Reference Functions (203 ms)
  apiVersions Should Be Recent
    [+] apiVersions Should Be Recent (137 ms)
  artifacts parameter
    [+] artifacts parameter (145 ms)
  CommandToExecute Must Use ProtectedSettings For Secrets
    [+] CommandToExecute Must Use ProtectedSettings For Secrets (171 ms)
  deploymentTemplate
    [-] Custom ParameterNaming (354 ms)
        To be implemented

  DependsOn Best Practices
    [+] DependsOn Best Practices (152 ms)
  Deployment Resources Must Not Be Debug
    [+] Deployment Resources Must Not Be Debug (152 ms)
  DeploymentTemplate Must Not Contain Hardcoded Uri
    [+] DeploymentTemplate Must Not Contain Hardcoded Uri (185 ms)
  DeploymentTemplate Schema Is Correct
    [+] DeploymentTemplate Schema Is Correct (197 ms)
  Dynamic Variable References Should Not Use Concat
    [+] Dynamic Variable References Should Not Use Concat (157 ms)
  IDs Should Be Derived From ResourceIDs
    [+] IDs Should Be Derived From ResourceIDs (69 ms)
  Location Should Not Be Hardcoded
    [+] Location Should Not Be Hardcoded (260 ms)
  ManagedIdentityExtension must not be used
    [+] ManagedIdentityExtension must not be used (70 ms)
  Min And Max Value Are Numbers
    [+] Min And Max Value Are Numbers (213 ms)
  Outputs Must Not Contain Secrets
    [+] Outputs Must Not Contain Secrets (76 ms)
  Parameter Types Should Be Consistent
    [+] Parameter Types Should Be Consistent (68 ms)
  Parameters Must Be Referenced
    [+] Parameters Must Be Referenced (93 ms)
  Password params must be secure
    [+] Password params must be secure (111 ms)
  providers apiVersions Is Not Permitted
    [+] providers apiVersions Is Not Permitted (68 ms)
  ResourceIds should not contain
    [+] ResourceIds should not contain (210 ms)
  Resources Should Have Location
    [+] Resources Should Have Location (113 ms)
  Resources Should Not Be Ambiguous
    [+] Resources Should Not Be Ambiguous (147 ms)
  Secure Params In Nested Deployments
    [+] Secure Params In Nested Deployments (242 ms)
  Secure String Parameters Cannot Have Default
    [+] Secure String Parameters Cannot Have Default (129 ms)
  Template Should Not Contain Blanks
    [+] Template Should Not Contain Blanks (201 ms)
  URIs Should Be Properly Constructed
    [+] URIs Should Be Properly Constructed (180 ms)
  Variables Must Be Referenced
    [+] Variables Must Be Referenced (132 ms)
  Virtual Machines Should Not Be Preview
    [+] Virtual Machines Should Not Be Preview (91 ms)
  VM Images Should Use Latest Version
    [+] VM Images Should Use Latest Version (114 ms)
  VM Size Should Be A Parameter
    [+] VM Size Should Be A Parameter (130 ms)
Pass  : 31
Fail  : 1
Total : 32

    Dopo aver trovato il test, lasciare aperta la finestra del terminale. Verrà usata in seguito.

Effettuare il refactoring del test personalizzato

A questo punto occorre procedere a un'implementazione adeguata del test personalizzato.

  1. Tornare all'editor di testo che contiene il file Custom-ParameterNaming.test.ps1.

    Nota

    Se Visual Studio Code è stato chiuso accidentalmente, passare alla sottodirectory arm-ttk/testcases/deploymentTemplate e aprire il file Custom-ParameterNaming.test.ps1.

  2. Sostituire il contenuto del file con il codice seguente:

    <#
.Synopsis
 Ensures that all parameters adheres to a naming standard
.Description
 All parameters should start with the company specific prefix 'tailwind'
#>
param(
   # The Template Object
   [Parameter(Mandatory = $true, Position = 0)]
   [PSObject]
   $TemplateObject,

   # The Template JSON Text
   [Parameter(Mandatory = $true, Position = 0)]
   [PSObject]
   $TemplateText
)

foreach ($parameter in $TemplateObject.parameters.psobject.properties) {
  # If the parameter name starts with tailwind, then the parameter is correctly named
  if ($parameter.Name -notmatch 'tailwind*') {
     Write-Error "Parameter '$($parameter.Name)' must start with prefix 'tailwind'" -TargetObject $parameter
  }
}

    Il codice precedente esegue l'iterazione di tutti i parametri. Controlla l'attributo name e verifica se il nome inizia con il prefisso tailwind. Se il parametro esaminato non corrisponde alla regola di denominazione, il codice chiama il cmdlet Write-Error con un messaggio di errore appropriato.

Aggiornare il file di modello

A questo punto si aggiungerà un parametro al file modello.

  1. Selezionare l'editor di testo che contiene il file azuredeploy.json e sostituire il contenuto del file con il contenuto seguente:

    {
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "location": {
      "type": "string",
      "metadata": {
        "description": "a deployment location"
      }
    }
  },
  "resources": []
}

    Il contenuto del modello precedente definisce una parametro location che non soddisfa la regola di denominazione perché il prefisso tailwind non è presente.

Eseguire di nuovo il toolkit di test

È stato scritto un test personalizzato. Tuttavia, la denominazione del file modello non soddisfa i requisiti. La successiva esecuzione del test è quindi destinata a non riuscire. Per accertarsene, eseguire il passaggio seguente.

Usare la finestra del terminale integrato di Visual Studio Code esistente in cui è stato avviato PowerShell ed è stato importato il toolkit di test.

In Visual Studio Code eseguire Test-AzTemplate dal terminale integrato:

Test-AzTemplate -TemplatePath . -Test Custom-ParameterNaming

Il comando precedente viene eseguito con il parametro -Test, che accetta un nome di test come input. Come parametro è stato specificato Custom-ParameterNaming, il che significa che verrà eseguito solo il test appena sviluppato.

Suggerimento

L'uso del parametro -Test è una procedura consigliata per lo sviluppo di un test, in quanto limita gli elementi che vengono eseguiti e le dimensioni dell'output del terminale.

Questo comando produce l'output seguente:

Validating custom\azuredeploy.json
 deploymentTemplate
   [-] Custom ParameterNaming (2ms)
       Parameter 'location' must start with prefix 'tailwind'

Il risultato indica che il test funziona. È possibile verificarlo modificando il file di distribuzione.

Correggere il file modello

A questo punto si vuole verificare la correttezza del test personalizzato modificando il file modello in modo che vengano applicate le regole definite dal test personalizzato.

  1. Nella stessa istanza di Visual Studio Code che visualizza il file azuredeploy.json sostituire il contenuto del file con il contenuto seguente:

    {
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "tailwindLocation": {
      "type": "string",
      "metadata": {
        "description": "a deployment location"
      }
    }
  },
  "resources": []
}

    Il parametro location è stato rinominato tailwindLocation. In teoria, questo parametro ora dovrebbe superare il test. Il passaggio seguente lo verificherà.

  2. Continuare con la stessa istanza di Visual Studio Code ed eseguire Test-AzTemplate nel terminale integrato:

    Test-AzTemplate -TemplatePath . -Test Custom-ParameterNaming

    L'output restituito è ora simile al seguente:

    Validating custom\azuredeploy.json
  deploymentTemplate
    [+] Custom ParameterNaming (2 ms)

Operazione riuscita. È stato implementato ed eseguito un test personalizzato. È stato anche corretto un modello di distribuzione in modo che corrisponda alla condizione del test.

Creare ed eseguire un test personalizzato

Si creerà un test personalizzato e si userà lo strumento del toolkit di test per eseguirlo. Si correggerà anche il modello di distribuzione per assicurarsi che il test venga superato. Il test personalizzato verificherà che tutti i parametri seguano una regola di denominazione. Questa regola è un requisito specifico del dominio del team responsabile di prodotto di cui si è membri.

Per eseguire questo esercizio è consigliabile tenere aperti due editor di testo:

  • Creare un test personalizzato. Individuare il percorso della sottodirectory arm-ttk/testcases/deploymentTemplate/ della directory di installazione del toolkit di test. Da questa sottodirectory verrà eseguito Visual Studio Code in cui verrà creato e modificato un test personalizzato.
  • Creare un file modello ed eseguire i test. Selezionare la posizione desiderata per il percorso. È consigliabile avviare un'istanza di Visual Studio Code da questo percorso in modo da poter modificare facilmente il file azuredeploy.json quando richiesto. Avviare un terminale integrato con questa istanza di Visual Studio Code per semplificare l'esecuzione dei test.

Creare il file di modello

Scegliere una directory e creare un file denominato azuredeploy.json.

Avviso

Verificare che la directory selezionata sia vuota, senza sottodirectory.

Aggiungere il contenuto seguente:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {},
  "resources": []
}

Creare il test personalizzato

  1. Aprire un terminale. Passare alla directory di installazione del toolkit di test. Posizionarsi nella sottodirectory arm-ttk/testcases/deploymentTemplate. Eseguire il comando riportato di seguito:

    code .

    Nota

    Se Visual Studio Code non è nel percorso, aprire Visual Studio Code manualmente e aprire la directory.

  2. Creare un file personalizzato denominato Custom-ParameterNaming.test.ps1. Inserire nel file il contenuto seguente:

    param(
[Parameter(Mandatory=$false,Position=0)] #not mandatory for case of an empty resource array
[PSObject]
$MainTemplateResources
)

Write-Error "To be implemented"

    Lasciare aperto l'editor di testo. Questo file verrà modificato in un secondo momento.

Eseguire il test personalizzato

Eseguire il test personalizzato seguendo questa procedura:

  1. Aprire una nuova finestra del terminale o riutilizzare quella precedente.

  2. Passare alla directory in cui è stato creato il file azuredeploy.json. Eseguire il comando seguente per avviare Visual Studio Code:

    code .

    Nota

    Se Visual Studio Code non è nel percorso, aprire Visual Studio Code manualmente e aprire la directory del modello.

  3. Da Visual Studio Code aprire il terminale integrato selezionando Terminale>Nuovo terminale nel menu principale. Eseguire il comando seguente nel terminale per avviare una shell di PowerShell:

    pwsh

    Verrà visualizzato un output simile al seguente:

    PowerShell 7.0.3
Copyright (c) Microsoft Corporation. All rights reserved.

https://aka.ms/powershell
Type 'help' to get help.

  4. Eseguire Import-Module nel terminale.

    Nota

    Prima di importare il modulo, sostituire path/to/arm-ttk/arm-ttk.psd1 con il percorso del toolkit di test scaricato.

    Import-Module path/to/arm-ttk/arm-ttk.psd1

    Suggerimento

    Se lo strumento è stato scaricato o clonato nella directory Download, il percorso dovrebbe essere simile a /Users/<user>/Downloads/arm-ttk/arm-ttk/arm-ttk.psd1.

    A questo punto è possibile iniziare a usare lo strumento. Se si rimane nella stessa sessione di PowerShell, non è necessario eseguire di nuovo il comando di importazione.

  5. Eseguire Test-AzTemplate nel terminale:

    Test-AzTemplate -TemplatePath .

    L'output è simile al seguente. Il test è indicato dalle righe evidenziate:

    Validating custom\azuredeploy.json
  JSONFiles Should Be Valid
    [+] JSONFiles Should Be Valid (56 ms)
Pass  : 1
Fail  : 0
Total : 1



  adminUsername Should Not Be A Literal
    [+] adminUsername Should Not Be A Literal (68 ms)
  apiVersions Should Be Recent In Reference Functions
    [+] apiVersions Should Be Recent In Reference Functions (203 ms)
  apiVersions Should Be Recent
    [+] apiVersions Should Be Recent (137 ms)
  artifacts parameter
    [+] artifacts parameter (145 ms)
  CommandToExecute Must Use ProtectedSettings For Secrets
    [+] CommandToExecute Must Use ProtectedSettings For Secrets (171 ms)
  deploymentTemplate
    [-] Custom ParameterNaming (354 ms)
        To be implemented

  DependsOn Best Practices
    [+] DependsOn Best Practices (152 ms)
  Deployment Resources Must Not Be Debug
    [+] Deployment Resources Must Not Be Debug (152 ms)
  DeploymentTemplate Must Not Contain Hardcoded Uri
    [+] DeploymentTemplate Must Not Contain Hardcoded Uri (185 ms)
  DeploymentTemplate Schema Is Correct
    [+] DeploymentTemplate Schema Is Correct (197 ms)
  Dynamic Variable References Should Not Use Concat
    [+] Dynamic Variable References Should Not Use Concat (157 ms)
  IDs Should Be Derived From ResourceIDs
    [+] IDs Should Be Derived From ResourceIDs (69 ms)
  Location Should Not Be Hardcoded
    [+] Location Should Not Be Hardcoded (260 ms)
  ManagedIdentityExtension must not be used
    [+] ManagedIdentityExtension must not be used (70 ms)
  Min And Max Value Are Numbers
    [+] Min And Max Value Are Numbers (213 ms)
  Outputs Must Not Contain Secrets
    [+] Outputs Must Not Contain Secrets (76 ms)
  Parameter Types Should Be Consistent
    [+] Parameter Types Should Be Consistent (68 ms)
  Parameters Must Be Referenced
    [+] Parameters Must Be Referenced (93 ms)
  Password params must be secure
    [+] Password params must be secure (111 ms)
  providers apiVersions Is Not Permitted
    [+] providers apiVersions Is Not Permitted (68 ms)
  ResourceIds should not contain
    [+] ResourceIds should not contain (210 ms)
  Resources Should Have Location
    [+] Resources Should Have Location (113 ms)
  Resources Should Not Be Ambiguous
    [+] Resources Should Not Be Ambiguous (147 ms)
  Secure Params In Nested Deployments
    [+] Secure Params In Nested Deployments (242 ms)
  Secure String Parameters Cannot Have Default
    [+] Secure String Parameters Cannot Have Default (129 ms)
  Template Should Not Contain Blanks
    [+] Template Should Not Contain Blanks (201 ms)
  URIs Should Be Properly Constructed
    [+] URIs Should Be Properly Constructed (180 ms)
  Variables Must Be Referenced
    [+] Variables Must Be Referenced (132 ms)
  Virtual Machines Should Not Be Preview
    [+] Virtual Machines Should Not Be Preview (91 ms)
  VM Images Should Use Latest Version
    [+] VM Images Should Use Latest Version (114 ms)
  VM Size Should Be A Parameter
    [+] VM Size Should Be A Parameter (130 ms)
Pass  : 31
Fail  : 1
Total : 32

    Dopo aver trovato il test, lasciare aperta la finestra del terminale. Verrà usata in seguito.

Effettuare il refactoring del test personalizzato

A questo punto occorre procedere a un'implementazione adeguata del test personalizzato.

  1. Tornare all'editor di testo che contiene il file Custom-ParameterNaming.test.ps1.

    Nota

    Se Visual Studio Code è stato chiuso accidentalmente, passare alla sottodirectory arm-ttk/testcases/deploymentTemplate e aprire il file Custom-ParameterNaming.test.ps1.

  2. Sostituire il contenuto del file con il codice seguente:

    <#
.Synopsis
 Ensures that all parameters adheres to a naming standard
.Description
 All parameters should start with the company specific prefix 'tailwind'
#>
param(
   # The Template Object
   [Parameter(Mandatory = $true, Position = 0)]
   [PSObject]
   $TemplateObject,

   # The Template JSON Text
   [Parameter(Mandatory = $true, Position = 0)]
   [PSObject]
   $TemplateText
)

foreach ($parameter in $TemplateObject.parameters.psobject.properties) {
  # If the parameter name starts with tailwind, then the parameter is correctly named
  if ($parameter.Name -notmatch 'tailwind*') {
     Write-Error "Parameter '$($parameter.Name)' must start with prefix 'tailwind'" -TargetObject $parameter
  }
}

    Il codice precedente esegue l'iterazione di tutti i parametri. Controlla l'attributo name e verifica se il nome inizia con il prefisso tailwind. Se il parametro esaminato non corrisponde alla regola di denominazione, il codice chiama il cmdlet Write-Error con un messaggio di errore appropriato.

Aggiornare il file di modello

A questo punto si aggiungerà un parametro al file modello.

  1. Selezionare l'editor di testo che contiene il file azuredeploy.json e sostituire il contenuto del file con il contenuto seguente:

    {
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "location": {
      "type": "string",
      "metadata": {
        "description": "a deployment location"
      }
    }
  },
  "resources": []
}

    Il contenuto del modello precedente definisce una parametro location che non soddisfa la regola di denominazione perché il prefisso tailwind non è presente.

Eseguire di nuovo il toolkit di test

È stato scritto un test personalizzato. Tuttavia, la denominazione del file modello non soddisfa i requisiti. La successiva esecuzione del test è quindi destinata a non riuscire. Per accertarsene, eseguire il passaggio seguente.

Nota

Usare la finestra del terminale integrato di Visual Studio Code esistente in cui è stato avviato PowerShell ed è stato importato il toolkit di test.

In Visual Studio Code eseguire Test-AzTemplate dal terminale integrato:

Test-AzTemplate -TemplatePath . -Test Custom-ParameterNaming

Il comando precedente viene eseguito con il parametro -Test, che accetta un nome di test come input. Come parametro è stato specificato Custom-ParameterNaming, il che significa che verrà eseguito solo il test appena sviluppato.

Suggerimento

L'uso di questo parametro è una procedura consigliata per lo sviluppo di un test, in quanto limita gli elementi che vengono eseguiti e le dimensioni dell'output del terminale.

Questo comando produce l'output seguente:

Validating custom\azuredeploy.json
 deploymentTemplate
   [-] Custom ParameterNaming (2ms)
       Parameter 'location' must start with prefix 'tailwind'

Il risultato indica che il test funziona. È possibile verificarlo modificando il file di distribuzione.

Correggere il file modello

A questo punto si vuole verificare la correttezza del test personalizzato modificando il file modello in modo che vengano applicate le regole definite dal test personalizzato.

  1. Nella stessa istanza di Visual Studio Code che visualizza il file azuredeploy.json sostituire il contenuto del file con il contenuto seguente:

    {
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "tailwindLocation": {
      "type": "string",
      "metadata": {
        "description": "a deployment location"
      }
    }
  },
  "resources": []
}

    Il parametro location è stato rinominato tailwindLocation. In teoria, questo parametro ora dovrebbe superare il test. Il passaggio seguente lo verificherà.

  2. Continuare con la stessa istanza di Visual Studio Code ed eseguire Test-AzTemplate nel terminale integrato:

    Test-AzTemplate -TemplatePath . -Test Custom-ParameterNaming

    L'output restituito è ora simile al seguente:

    Validating custom\azuredeploy.json
  deploymentTemplate
    [+] Custom ParameterNaming (2 ms)

Operazione riuscita. È stato implementato ed eseguito un test personalizzato. È stato anche corretto un modello di distribuzione in modo che corrisponda alla condizione del test.

Creare ed eseguire un test personalizzato

Si creerà un test personalizzato e si userà lo strumento del toolkit di test per eseguirlo. Si correggerà anche il modello di distribuzione per assicurarsi che il test venga superato. Il test personalizzato verificherà che tutti i parametri seguano una regola di denominazione. Questa regola è un requisito specifico del dominio del team responsabile di prodotto di cui si è membri.

Per eseguire questo esercizio è consigliabile tenere aperti due editor di testo:

  • Creare un test personalizzato. Individuare il percorso della sottodirectory arm-ttk\testcases\deploymentTemplate\ della directory di installazione del toolkit di test. Da questa sottodirectory verrà eseguito Visual Studio Code in cui verrà creato e modificato un test personalizzato.
  • Creare un file modello ed eseguire i test. Selezionare la posizione desiderata per il percorso. È consigliabile avviare un'istanza di Visual Studio Code da questo percorso in modo da poter modificare facilmente il file azuredeploy.json quando richiesto. Avviare un terminale integrato con questa istanza di Visual Studio Code per semplificare l'esecuzione dei test.

Creare il file di modello

Scegliere una directory e creare un file denominato azuredeploy.json.

Avviso

Verificare che la directory selezionata sia vuota, senza sottodirectory.

Aggiungere il contenuto seguente:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {},
  "resources": []
}

Creare il test personalizzato

  1. Aprire un terminale.

  2. Passare alla directory di installazione del toolkit di test.

  3. Posizionarsi nella sottodirectory arm-ttk\testcases\deploymentTemplate.

  4. Eseguire il comando riportato di seguito:

    code .

    Nota

    Se Visual Studio Code non è nel percorso, aprire Visual Studio Code manualmente e aprire la directory.

  5. Creare un file denominato Custom-ParameterNaming.test.ps1 e aggiungere al file il contenuto seguente:

    param(
[Parameter(Mandatory=$false,Position=0)] #not mandatory for case of an empty resource array
[PSObject]
$MainTemplateResources
)

Write-Error "To be implemented"

    Lasciare aperto l'editor di testo. Questo file verrà modificato in un secondo momento.

Eseguire il test personalizzato

Eseguire il test personalizzato seguendo questa procedura:

  1. Aprire una nuova finestra del terminale o riutilizzare quella precedente.

  2. Passare alla directory in cui è stato creato il file azuredeploy.json.

  3. Eseguire il comando seguente per avviare Visual Studio Code:

    code .

    Nota

    Se Visual Studio Code non è nel percorso, aprire Visual Studio Code manualmente e aprire la directory del modello.

  4. Aprire il terminale integrato in Visual Studio Code. Aprire il riquadro comandi, digitare PowerShell e selezionare Show integrated terminal (Mostra terminale integrato).

  5. Eseguire il comando seguente nel terminale:

    Nota

    Prima di importare il modulo, sostituire path\to\arm-ttk\arm-ttk.psd1 con il percorso del toolkit di test scaricato.

    Import-Module path\to\arm-ttk\arm-ttk.psd1

    Suggerimento

    Se lo strumento è stato scaricato o clonato nella directory Download, il percorso dovrebbe essere simile a C:\Users\<user>\Downloads\arm-ttk\arm-ttk\arm-ttk.psd1.

    A questo punto è possibile iniziare a usare lo strumento. Se si rimane nella stessa sessione di PowerShell, non è necessario eseguire di nuovo il comando di importazione.

  6. Eseguire Test-AzTemplate nel terminale:

    Test-AzTemplate -TemplatePath .

    L'output è simile al seguente. Il test è indicato dalle righe evidenziate:

    Validating custom\azuredeploy.json
  JSONFiles Should Be Valid
    [+] JSONFiles Should Be Valid (56 ms)
Pass  : 1
Fail  : 0
Total : 1



  adminUsername Should Not Be A Literal
    [+] adminUsername Should Not Be A Literal (68 ms)
  apiVersions Should Be Recent In Reference Functions
    [+] apiVersions Should Be Recent In Reference Functions (203 ms)
  apiVersions Should Be Recent
    [+] apiVersions Should Be Recent (137 ms)
  artifacts parameter
    [+] artifacts parameter (145 ms)
  CommandToExecute Must Use ProtectedSettings For Secrets
    [+] CommandToExecute Must Use ProtectedSettings For Secrets (171 ms)
  deploymentTemplate
    [-] Custom ParameterNaming (354 ms)
        To be implemented

  DependsOn Best Practices
    [+] DependsOn Best Practices (152 ms)
  Deployment Resources Must Not Be Debug
    [+] Deployment Resources Must Not Be Debug (152 ms)
  DeploymentTemplate Must Not Contain Hardcoded Uri
    [+] DeploymentTemplate Must Not Contain Hardcoded Uri (185 ms)
  DeploymentTemplate Schema Is Correct
    [+] DeploymentTemplate Schema Is Correct (197 ms)
  Dynamic Variable References Should Not Use Concat
    [+] Dynamic Variable References Should Not Use Concat (157 ms)
  IDs Should Be Derived From ResourceIDs
    [+] IDs Should Be Derived From ResourceIDs (69 ms)
  Location Should Not Be Hardcoded
    [+] Location Should Not Be Hardcoded (260 ms)
  ManagedIdentityExtension must not be used
    [+] ManagedIdentityExtension must not be used (70 ms)
  Min And Max Value Are Numbers
    [+] Min And Max Value Are Numbers (213 ms)
  Outputs Must Not Contain Secrets
    [+] Outputs Must Not Contain Secrets (76 ms)
  Parameter Types Should Be Consistent
    [+] Parameter Types Should Be Consistent (68 ms)
  Parameters Must Be Referenced
    [+] Parameters Must Be Referenced (93 ms)
  Password params must be secure
    [+] Password params must be secure (111 ms)
  providers apiVersions Is Not Permitted
    [+] providers apiVersions Is Not Permitted (68 ms)
  ResourceIds should not contain
    [+] ResourceIds should not contain (210 ms)
  Resources Should Have Location
    [+] Resources Should Have Location (113 ms)
  Resources Should Not Be Ambiguous
    [+] Resources Should Not Be Ambiguous (147 ms)
  Secure Params In Nested Deployments
    [+] Secure Params In Nested Deployments (242 ms)
  Secure String Parameters Cannot Have Default
    [+] Secure String Parameters Cannot Have Default (129 ms)
  Template Should Not Contain Blanks
    [+] Template Should Not Contain Blanks (201 ms)
  URIs Should Be Properly Constructed
    [+] URIs Should Be Properly Constructed (180 ms)
  Variables Must Be Referenced
    [+] Variables Must Be Referenced (132 ms)
  Virtual Machines Should Not Be Preview
    [+] Virtual Machines Should Not Be Preview (91 ms)
  VM Images Should Use Latest Version
    [+] VM Images Should Use Latest Version (114 ms)
  VM Size Should Be A Parameter
    [+] VM Size Should Be A Parameter (130 ms)
Pass  : 31
Fail  : 1
Total : 32

    Dopo aver trovato il test, lasciare aperta la finestra del terminale. Verrà usata in seguito.

Effettuare il refactoring del test personalizzato

A questo punto occorre procedere a un'implementazione adeguata del test personalizzato.

  1. Tornare all'editor di testo che contiene il file Custom-ParameterNaming.test.ps1.

    Nota

    Se Visual Studio Code è stato chiuso accidentalmente, passare alla sottodirectory testcases/deploymentTemplate e aprire il file Custom-ParameterNaming.test.ps1.

  2. Sostituire il contenuto del file con il codice seguente:

    <#
.Synopsis
 Ensures that all parameters adheres to a naming standard
.Description
 All parameters should start with the company specific prefix 'tailwind'
#>
param(
   # The Template Object
   [Parameter(Mandatory = $true, Position = 0)]
   [PSObject]
   $TemplateObject,

   # The Template JSON Text
   [Parameter(Mandatory = $true, Position = 0)]
   [PSObject]
   $TemplateText
)

foreach ($parameter in $TemplateObject.parameters.psobject.properties) {
  # If the parameter name starts with tailwind, then the parameter is correctly named
  if ($parameter.Name -notmatch 'tailwind*') {
     Write-Error "Parameter '$($parameter.Name)' must start with prefix 'tailwind'" -TargetObject $parameter
  }
}

    Il codice precedente esegue l'iterazione di tutti i parametri. Controlla l'attributo name e verifica se il nome inizia con il prefisso tailwind. Se il parametro esaminato non corrisponde alla regola di denominazione, il codice chiama il cmdlet Write-Error con un messaggio di errore appropriato.

Aggiornare il file di modello

A questo punto si aggiungerà un parametro al file modello.

  1. Selezionare l'editor di testo che contiene il file azuredeploy.json e sostituire il contenuto del file con il contenuto seguente:

    {
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "location": {
      "type": "string",
      "metadata": {
        "description": "a deployment location"
      }
    }
  },
  "resources": []
}

    Il contenuto del modello precedente definisce una parametro location che non soddisfa la regola di denominazione perché il prefisso tailwind non è presente.

Eseguire di nuovo il toolkit di test

È stato scritto un test personalizzato. Tuttavia, la denominazione del file modello non soddisfa i requisiti. La successiva esecuzione del test è quindi destinata a non riuscire. Per accertarsene, eseguire il passaggio seguente.

Usare la finestra del terminale integrato di Visual Studio Code esistente in cui è stato avviato PowerShell ed è stato importato il toolkit di test.

In Visual Studio Code eseguire Test-AzTemplate dal terminale integrato:

Test-AzTemplate -TemplatePath . -Test Custom-ParameterNaming

Il comando precedente viene eseguito con il parametro -Test, che accetta un nome di test come input. Come parametro è stato specificato Custom-ParameterNaming, il che significa che verrà eseguito solo il test appena sviluppato.

Suggerimento

L'uso di questo parametro è una procedura consigliata per lo sviluppo di un test, in quanto limita gli elementi che vengono eseguiti e le dimensioni dell'output del terminale.

Questo comando produce l'output seguente:

Validating custom\azuredeploy.json
 deploymentTemplate
   [-] Custom ParameterNaming (2ms)
       Parameter 'location' must start with prefix 'tailwind'

Il risultato indica che il test funziona. È possibile verificarlo modificando il file di distribuzione.

Correggere il file modello

A questo punto si vuole verificare la correttezza del test personalizzato modificando il file modello in modo che vengano applicate le regole definite dal test personalizzato.

  1. Nella stessa istanza di Visual Studio Code che visualizza il file azuredeploy.json sostituire il contenuto del file con il contenuto seguente:

    {
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "tailwindLocation": {
      "type": "string",
      "metadata": {
        "description": "a deployment location"
      }
    }
  },
  "resources": []
}

    Il parametro location è stato rinominato tailwindLocation. In teoria, questo parametro ora dovrebbe superare il test. Il passaggio seguente lo verificherà.

  2. Continuare con la stessa istanza di Visual Studio Code ed eseguire Test-AzTemplate nel terminale integrato:

    Test-AzTemplate -TemplatePath . -Test Custom-ParameterNaming

    L'output restituito è ora simile al seguente:

    Validating custom\azuredeploy.json
  Custom ParameterNaming
    [+] Custom ParameterNaming (9 ms)

Operazione riuscita. È stato implementato ed eseguito un test personalizzato. È stato anche corretto un modello di distribuzione in modo che corrisponda alla condizione del test.