Il presente articolo è stato tradotto automaticamente.

Applicazioni moderne

A fine test nei moderni siti Web e applicazioni

Rachel Appel

Il software è più complesso di quanto mai prima. Se è un'applicazione per Windows, iOS, Web, Android, un dispositivo Internet of Things (IoT) o un smartwatch — che il software sta facendo molto. Di conseguenza, il software deve essere accurato. Deve operare secondo specifiche. Così è per gli sviluppatori per testare il loro software.

Senza prove, è difficile verificare se il codice fa quello che dovrebbe. Inoltre è più difficile per isolare il codice per correggere i bug. Mentre è importante eseguire il test, è anche importante eseguire il test per le giuste ragioni, non solo per l'amor di testing o vantarsi diritti circa 100% copertura. Piccolo test smart conquistare sempre di prove insignificanti che coprono l'intera base di codice. Questo articolo riguarderà come all'unità di prova codice lato server e client, così come il modo di automatizzare UI test con UI test (scelta) codificati. Queste tre aree fondamentali di prova metterà alla prova i principali aspetti della funzionalità del software.

Unità di unità

Unit test aiuto ridurre i bug e fornire la documentazione per il codice che stai testando. Regressione, accettazione utente, automazione interfaccia utente e altre misure di garanzia della qualità sono importanti. I bilanci sono spesso stretti e squadre sono piccole, tante volte devi scegliere uno sopra l'altro. Sta a voi decidere quanto garanzia di qualità va in app. Al minimo, unit test e test dell'interfaccia utente vi aiuterà a mantenere la qualità alta.

Ci sono un certo numero di open source e pacchetti software unit test commerciali disponibili. Molti dei test suite popolare pubblicare un pacchetto di NuGet, quindi si può facilmente scaricare direttamente in Visual Studio. Alcuni dei popolari c# Framework di test sono xUnit, nUnit, MSTest e TestDriven.NET. Per il test JavaScript, c'è qUnit, JSUnit e Test di YUI.

Mentre gli unit test è spesso il tipo predefinito di test, ci sono altri modi per testare il software. Quelli includono automazione interfaccia utente o scelta, test di accettazione utente, test di regressione, test di integrazione e tutti i tipi di prove speciali. Wikipedia elenca decine di modi per testare il software presso bit.ly/14066q8.

Buona unit test prova solo una funzione per ogni prova. Il principio di responsabilità singola (SRP) è un modo per garantire che il codice è modulare. SRP significa il codice si concentra su una cosa e fa bene, che cosa sia il codice di implementazione o la prova stessa. Unit test non dovrebbe accedere direttamente al database, file o altre risorse. Essi devono basarsi su oggetti fittizi che simulano quelle risorse e, come con qualsiasi altro codice, unit test dovrebbero essere piccoli.

Un altro modo per scrivere buone prove è aderendo ai principi di test driven development (TDD). TDD è un modo per sviluppare codice intorno una suite di test. Lo sviluppatore crea test che falliscono, scrive il codice corretto per essere conforme alla prova, quindi effettua il refactoring. Io lo chiamo, "Rosso, verde, Refactor." Questa tecnica consente di strutturare e scrivere codice in modo coerente. E la coerenza è una virtù nello sviluppo di software. Sebbene TDD è fuori dallo scopo di questo articolo, esaminare e provarlo con il vostro team.

Questo articolo riguarderà gli unit test con xUnit e qUnit. Guarderò anche automazione interfaccia utente test con scelta. In questo modo si può diventare familiare con i più importanti tipi di test, sarà necessario.

Prova sul lato Server c# con xUnit

Sarete lieti di scoprire come è facile integrare un pacchetto di unit test in Visual Studio. Molti Framework sono disponibili come pacchetto NuGet. Ad esempio, se si desidera utilizzare xUnit, basta avviare NuGet Gestione pacchetti, cercare "xUnit", quindi fai clic per installare il pacchetto di base e relativo pacchetto di test runner. È possibile utilizzare xUnit per testare siti Web ASP.NET , Windows Form, Windows Presentation Foundation (WPF), Windows Store e Windows Phone apps, oltre qualsiasi linguaggio che viene compilato in codice Microsoft Intermediate Language, o MSIL. È possibile anche unità di test F # utilizzando xUnit — che è di tutte le tecnologie di sviluppo Microsoft.

Per utilizzare xUnit, aggiungere un progetto libreria di classi alla soluzione. Per semplicità, si potrebbe voler mantenere alle convenzioni di denominazione comune e usare qualcosa come ProjectName.Tests, dove "NomeProgetto" è il nome del progetto che si sta testando. Nel test, accertarsi di che aggiungere un riferimento a tale progetto. Quindi nome e aggiungere un file di classe per il test e una classe per la prova di qualcosa.

Figura 1 Mostra un esempio di una classe di test xUnit con un test, insieme con il codice di verifica. Il codice in Figura 1 determina lo stato di un cliente basato su quanto hanno speso. I test in Figura 1 garantire il codice è corretto.

Figura 1 test un campione di xUnit codice

// Unit tests that test customer-related features
public class CustomerTests
{
  [Theory]
  [InlineData(99D)]
  [InlineData(1001D)]
  [InlineData(5001D)]
  [InlineData(10001D)]
  public void VerifyCustomerStatus(double TotalSpent) {
    // Arrange           
    var status = new Status();
    var testStatus=OrderForm.Models.Status.StatusLevel.None;
    // Act
    var currentStatus = status.GetCurrentStatus(TotalSpent);
    // Assert           
    Assert.True(testStatus <= currentStatus);
  }
}
// Logic that sets the customer status
public class Status
{
  public StatusLevel GetCurrentStatus(decimal ForAmount)
  {
    var level = StatusLevel.None;
    var amt = Convert.ToInt32(ForAmount);
    if (amt > 1000 && amt <= 5000) { level = StatusLevel.Silver; }
    else if (amt > 5000 && amt <= 10000) { level = StatusLevel.Gold; }
    else if (amt > 10000) { level = StatusLevel.Platinum; }
    return level;
  }
  public enum StatusLevel
  {
    None = 0,
    Silver = 1,
    Gold = 2,
    Platinum = 3
  }          
}

All'interno di metodi di unit test, troverete arrange popolare, agire, far valere (o AAA) modello, che è anche indicato nel Figura 1. Prima di organizzare le condizioni di prova, quindi agire su tali condizioni e, ultima, affermare l'output.

È possibile utilizzare AAA su qualsiasi cosa, ma se volete la qualità del software, è necessario disporre di prove significative. Collaudo quadri tendono a venire con una flotta di asserzioni, come Equal, NotEqual, stesso, NotSame, Contains, DoesNotContain, sensitività, IsNotEmpty e molti altri. Naturalmente, l'esatta denominazione o metodi non saranno lo stesso, ma ogni quadro ti dà diverse tra cui scegliere.

Avrete notato la [teoria] e [InlineData] attributi, decorando la classe di test, anziché l'attributo [Test] popolare. Quando i metodi di prova non sono parametri, in xUnit è possibile utilizzare l'attributo [fatto] contrassegnare il metodo come un metodo di prova. Queste annotazioni di dati lasciate che il test accetta il parametro TotalSpent che vedete nella firma del metodo di prova in Figura 1. Un test verrà eseguito per ogni [InlineData] attributo su un metodo e visualizza i risultati di ogni test in Visual Studio testo Explorer, come mostrato Figura 2.

Figura 2 il metodo di Test VerifyCustomerStatus con quattro punti di dati in Esplora Test

È possibile utilizzare un menu di scelta rapida su prove in Explorer Test in qualsiasi momento per rivelare le opzioni di esecuzione, eseguire il debug, analizzare, profilo e così via. Ogni volta che si cambia codice o prove, deve compilare ed eseguire il test. È possibile impostare l'opzione di eseguire automaticamente test su ogni compilazione andando al menu Test Visual Studio , selezionando impostazioni di Test, quindi selezionando Esegui test dopo costruire.

Non otterrete lontano con unit test prima si imbatterà in necessità di oggetti fittizi. Generalmente, quando si tenta di un database di test, non volete modificare i dati effettivi dal vivo. Pertanto, è possibile utilizzare beffardo come un modo per simulare il database effettivo, Web oggetto del servizio o di affari. Beffardo è fuori dallo scopo di questo articolo, così quando si arriva a quel punto, cercare nel Web Moq, Telerik JustMock o Rhino Mocks. Tutti sono popolari beffardo titoli software con documentazione completa e supporto.

Test JavaScript lato Client con qUnit

QUnit è un framework di test JavaScript lato client. È leggero, semplice e facile da usare. È possibile utilizzare qUnit per testare qualsiasi JavaScript o jQuery. Perché hai a che fare con JavaScript lato client, ci possono essere attività nell'interfaccia utente accadendo che non devi testare. È possibile ignorare aspetti quali si libra link o modifiche estetico dell'interfaccia utente. È inoltre possibile utilizzare automazione interfaccia utente test per coprire il test dell'interfaccia utente. Le regole di business, codice API e convalida sul lato server devono tutti avere buona copertura. Qualsiasi JavaScript che esegue la convalida e logica ha bisogno di test, pure.

A differenza dei test di linguaggio compilato che si integrano direttamente con Visual Studio, dovrete costruire qUnit test harness. È abbastanza facile, però e prende circa 17 linee di codice che è possibile copiare da Figura 3.

Figura 3 il qUnit HTML Test Harness

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>Qunit Unit Testing</title>
  <link href="Content/qunit.css" rel="stylesheet" />
</head>
<body>
  <h1 id="qunit-header">QUnit Test Suite</h1>
  <h2 id="qunit-banner"></h2>
  <div id="qunit-testrunner-toolbar"></div>
  <h2 id="qunit-userAgent"></h2>
  <ol id="qunit-tests"></ol>
  <script src="Scripts/qunit.js"></script>      
  <script src="Scripts/logic.js"></script>
  <script src="Scripts/tests.js"></script>   
</body>
</html>

Figura 3 Mostra riferimenti a qunit.css, poi qunit.js, logic.js e tests.js. L'ordine è importante. È necessario caricare qunit.js prima la logica e la logica prima delle prove. È possibile il nome logic.js quello che volete, come è il tuo codice. Ci possono essere più file js tra qunit.js e le prove. La struttura HTML della pagina di prova imbrago contiene alcuni tag di intestazione, così come un elenco ordinato che visualizza i risultati del test individuali. Tutti gli stili per questi sono nel file qunit.css. Come best practice, mettere solo i riferimenti JavaScript alla fine della pagina Web immediatamente prima della chiusura lt; / body > Tag, come mostrato Figura 3.

Per testare con qUnit, potete posizionare il test in un file js e denominarlo tests.js. Qui, c'è una chiamata alla funzione qUnit test, che accetta il nome della funzione da chiamare stringa, e una funzione anonima che effettivamente esegue il test. Il nome passato nella funzione test si presenta come il nome del test nel corridore di prova, come mostrato Figura 4. Invece passando i parametri di test, utilizzare la natura dinamica di JavaScript per chiamare il codice in questione più volte utilizzando molteplici asserzioni. Figura 5 spettacoli l'output di più afferma nel VerifyCustomerStatus test di funzionalità.

Figura 4 QUnit test la funzione getCurrentStatus e la logica stessa in JavaScript

// Tests to test customer statuses
test('VerifyCustomerStatus', function () {
  var silver = getCurrentStatus(1001);
  equals(silver, "Silver", "Pass");
  var gold = getCurrentStatus(5001);
  equals(gold, "Gold", "Pass");
  var platinum = getCurrentStatus(10001);
  equals(platinum, "Platinum", "Pass");
})
// Logic to set customer statuses
function getCurrentStatus(amt) {
  if (amt > 1000 && amt <= 5000) { return "Silver"; }
  else if (amt > 5000 && amt <= 10000) { return "Gold"; }
  else if (amt > 10000) { return "Platinum"; }
  return "None";
}

Figura 5 risultati delle prove di qUnit nel Browser

Se stai scrivendo Windows Store o Windows Phone apps utilizzando la libreria Windows per JavaScript (WinJS), non temere. C'è un qUnitMetro è possibile scaricare a bit.ly/1F2RsO7. Questo pacchetto consente qUnit eseguire nel contenitore dell'app store, proprio come farebbe in una pagina Web. La codificazione e il modo di scrivere i test sono identici a qUnit, perché è davvero qUnit.

L'interfaccia utente con la scelta di testare

Quando hai bisogno di automatizzare i test per le interfacce utente nativi, girare a scelta. Scelta sembra essere una caratteristica di test poco conosciuto in Visual Studio. È possibile creare scelta in Visual Studio per le applicazioni Web, Windows Store e Windows Phone. Visual Studio Scelta possibile testare qualsiasi interfaccia utente su Windows. Non è necessario anche il codice sorgente per un'interfaccia utente di prova. È possibile configurare le prove per indirizzare qualsiasi programma in esecuzione.

Ci sono modelli di Visual Studio per il programma base, interfacce utente, Web, Windows Store e Windows Phone. Quando si crea un progetto da uno di questi modelli, Visual Studio lancerà voi direttamente nelle finestre di dialogo prime, mostrato Figura 6, chiede se si desidera registrare nuove prove o modificare quelli esistenti. Selezionare "Registra azioni, modificare la mappa dell'interfaccia utente o aggiungere asserzioni" e apparirà una finestra degli strumenti (vedere Figura 7). Questa finestra di dialogo e strumento stessa apparirà ogni volta che aggiungete un nuovo file CUIT a un progetto (File | Nuovo elemento). A questo punto, potete fare clic su record e poi iniziare a interagire con la tua pagina Web o l'applicazione UI.

Figura 6 il dialogo Visual Studio Visualizza per registrare o modificare UI test codificati

Figura 7 lo strumento per registrare e modificare le asserzioni

Quando hai finito, fai clic sul pulsante Aggiungi e genera nella parte inferiore della finestra (vedere Figura 8), aggiungere metadati descrittivi e dettagliato e lasciato Visual Studio per generare il codice.

Figura 8 le finestre di dialogo che creare Coded UI test

Quando si crea un progetto di Coded UI e aggiungervi un Coded UI Test, Visual Studio genera una discreta quantità di codice. Tuttavia, Visual Studio è abbastanza intelligenti su come genera il codice di test. L'uscita è pulito, soprattutto per il codice generato. Visual Studio genera il codice di registrazione le vostre azioni durante l'utilizzo di un particolare programma. Se si fa clic sul record nella casella degli strumenti in Figura 7, il registratore registra cosa fare per generare il codice che esegue la stessa azione. Sei libero di scrivere questo codice, ma è più facile averlo generato.

Una volta che hai finito con il generatore di Test codificati dell'interfaccia utente, Visual Studio crea alcuni file, il primo è il Coded UI test. Questo è un file. cs e contiene una classe con metodi che eseguono le stesse operazioni che un utente vorrebbe utilizzare un'interfaccia utente. Gli altri file sono file di mappa: UIMap. UITest, UIMap.cs e UIMap.designer.cs. A differenza dei tradizionali Visual Studio progettisti che sono noti per la generazione di troppo codice, quest'ultimo si comporta molto meglio. È facile modificare il test senza il designer ottenere nel vostro senso. In qualsiasi momento, è possibile modificare la finestra di progettazione facendo clic destro sul file .uitest e selezionando Edit con generatore di Test codificati dell'interfaccia utente tra le opzioni. Questo lancia la casella degli strumenti si è visto in Figura 7. Di nuovo, siete liberi di scrivere il tuo test manualmente. Prima di decidere, date un'occhiata ad alcuni del codice generato che esegue queste quattro prove:

1. Prove di creazione di un nuovo cliente correttamente
2. Prove di creazione di un nuovo cliente senza immettere un nome
3. Prove di creazione di un nuovo cliente senza immettere un indirizzo
4. Prove di creazione di un nuovo cliente entrando in un formato non valido codice postale

Potete trovare i quattro test nel file di progettazione e codice nella classe di Coded UI test li chiama in successione, come si può vedere Figura 9.

Figura 9 contenuto parziale dei file firmati Test codificato dell'interfaccia utente e mappa

// In the Coded UI Test C# file
[CodedUITest]
  public class CodedUITest1
  {
    [TestMethod]
    public void CodedUITestMethod1()
    {
      this.UIMap.CreateNewCustomerCorrectly();
      this.UIMap.CreateNewCustomerWithoutName();
      this.UIMap.CreateNewCustomerWithoutAddress();
      this.UIMap.CreateNewCustomerWihtoutValidPostalCode();       
    }
    // Some other framework code for Coded UI
  }
// In the Coded UI UIMap.Designer.cs file
public void CreateNewCustomerWithoutName()
    {
      #region Variable Declarations
      // Click 'Create New' link
      Mouse.Click(uICreateNewHyperlink, new Point(51, 8));
      // Type '' in 'Name' text box
      uINameEdit.Text = this.CreateNewCustomerMissingNameParams.UINameEditText;
      // Type '{Tab}' in 'Name' text box
      Keyboard.SendKeys(uINameEdit,
        this.CreateNewCustomerMissingNameParams.UINameEditSendKeys,
        ModifierKeys.None);
      // Type '234 Lane St' in 'Address' text box
      uIAddressEdit.Text =
        this.CreateNewCustomerMissingNameParams.UIAddressEditText;
      // Type '{Tab}' in 'Address' text box
      Keyboard.SendKeys(uIAddressEdit,
        this.CreateNewCustomerMissingNameParams.UIAddressEditSendKeys,
        ModifierKeys.None);
  }
}

Test codificati dell'interfaccia utente sono proprio come qualsiasi altro test. Sono per l'interazione con l'interfaccia utente, proprio come farebbe un utente. Fortunatamente, lo strumento di interfaccia utente codificato è ottimo per registrare le vostre azioni e generazione di codice che fa la stessa cosa. In qualsiasi momento, si può scartare e rigenerare le prove o modificare il codice senza preoccuparsi. Anche come unità di analisi, è possibile eseguire il test Coded UI da Visual Studio Esplora Test. Essi mostrerò accanto gli unit test.

Migliorare la qualità del Software

Ci sono vantaggi reali da varie forme di sperimentazione. È importante testare anche piccole applicazioni Windows Store o Windows Phone, soprattutto se li vendi in un deposito di app. Testato app sono applicazioni che funzionano in modo affidabile — hanno documentazione e un audit trail.

Si può prova di unità con librerie come xUnit e qUnit e utilizzare l'automazione test per Web o applicazioni native con scelta. Che è non parlare di altri tipi di test importante come test, test, sistemi di test e così via di integrazione di accettazione utente. Aggiungendo queste, una volta che hai un solido set di unità e UI test migliorerà notevolmente la qualità del software.

---

Rachel Appel è un consulente, autore, mentore ed ex dipendente di Microsoft con più di 20 anni di esperienza nel settore IT. Lei parla a conferenze di settore superiore come Visual Studio Live!, DevConnections, Mix e altro ancora. Sua competenza si trova all'interno di sviluppare soluzioni che allineare business e tecnologia concentrandosi sullo stack Microsoft dev e aprire il Web. Per ulteriori informazioni su Appel, visitare il suo Web site a rachelappel.com.

Grazie all'esperto tecnica seguente per la revisione di questo articolo: Oren Novotony