lunedì 8 giugno 2015

Cloud Load Test con Visual Studio Online - parte 2: Visual Studio

Questo articolo è il secondo di una serie di 3 in cui parlo del Cloud Load Testing con Visual Studio Online.

Nella prima parte abbiamo visto come eseguire dei semplici test di carico usando solamente il portale di VSO.
In questo articolo invece vedremo un soluzione più complessa (ma più completa), l'integrazione tra Visual Studio e Visual Studio Online.

Remainder
Prima di iniziare a parlare nello specifico dell'esecuzione dei Cloud Load Test è importante ricordare alcuni aspetti:

  • Per poter utilizzare la funzionalità di Cloud Load Test è necessario avere una sottoscrizione MSDN Ultimate
  • L'applicazione da testare deve essere esposta sul web (visto che i test agent sono nel cloud e devono poter raggiungere l'applicazione)
  • Gratuitamente si possono utilizzare fino a 20.000 minuti al mese. Si tratta di "virtual user minutes", quindi ad esempio eseguendo 1 test da 2 minuti con un carico costante di 200 virtual user si consumeranno 400 virtual user minutes.

Inoltre, la funzionalità di Load test è disponibile solamente su Visual Studio Ultimate/Enterprise.

Fatte queste precisazioni, vediamo come si possono creare ed eseguire i test di carico con Visual Studio e Visual Studio Online.


Introduzione
Facendo un Load test con Visual Studio, avremo un sacco di impostazioni che potremo configurare. Si tratta quindi della soluzione più personalizzabile e configurabile per eseguire questo tipo di test.
Inoltre, dopo l'esecuzione avremo a disposizione molte informazioni, dati e grafici che ci permetterranno di capire come la nostra applicazione si comporta in uno scenario di carico.

Ultimo ma non per importanza, utilizzando VS possiamo fare un test multi step (multi pagina), anche con pagine sottoposte ad autenticazione, e possiamo registrare tutti i passaggi che vogliamo fare nell'applicazione allo stesso modo di come li farebbe l'utente (quindi non è richiesta configurazione manuale!).


Iniziamo
Prima di tutto dobbiamo creare un test project in Visual Studio. Il project template da usare è "Web Performance and Load Test Project".


Quando clicchiamo sul bottone "Ok", VS crea per noi una soluzione (come sempre) con all'iterno un progetto "WebTest1.webtest". Non si tratta di un progetto di "Cloud Test", bensì di un progetto "Web Performance". Avremo bisogno di questo progetto per "istruire" il load test su cosa e come testare.

In alto a sinistra della schermata c'è un piccolo bottone con un grosso punto rosso: è il bottone che ci permette di resgistrare tutti gli step che faremo nella nostra applicazione.


Se clicchiamo su questo bottone, verrà aperto il browser (tipicamente IE) che avrà un piccolo pannello sulla sinistra. Si tratta del pannello che "fa il lavoro per noi"; è generato dal plugin "Web Test Recorder helper" che VS installa sulla nostra macchina.


Come nota a margine, ricordate di verificare che quel plugin sia abilitato sul browser altrimenti non verrà visualizzato nulla.


Ok, ora che la registrazione è attiva possiamo visitare ed usare l'applicazione che vogliamo testare esattamente come farebbe un normale utente. Possiamo anche eseguire azioni particolari se vogliamo testare qualche funzionalità o pagina specifica.
Per far iniziare la registrazione è sufficiente scrivere l'indirizzo dell'applicazione nella barra del browser ed iniziare ad usarla: il web recorder plugin farà tutto il resto.

Quando abbiamo finito, abbiamo cioè effettuato tutti gli step e le navigazioni che vogliamo testare, basta clicare sul bottone "Stop". Abbiamo anche la possibilità di mettere in pausa la registrazione se magari non vogliamo registrare qualche step.


Mentre navighiamo la nostra applicazione, un sacco di "roba" viene aggiunta nel pannello di registrazione. Si tratta di tutte le richieste che la nostra applicazione fa.
Se ne selezioniamo una e clicchiamo sul bottone "comment" possiamo aggiungere un commento alla stessa che sarà possibile recuperare in un secondo momento.

Quando clicchiamo sul bottone "Stop", succede "la magia". Dapprima Visual Studio prende tutte le richieste e le informazioni dal web recorder plugin, le elabora e le inserisce nella finestra del webtest. Poi cerca di identificare se ci sono dei "parametri dinamici" nel nostro test.


I dynamic parameters sono tutti quei valori che possono cambiare se le richieste vengono fatte in momenti temporali differenti: user token, ricerche, autenticazioni, ecc. Se VS ne rileva qualcuno ci mostrerà una finestra in cui potremo decidere come e se utilizzarli. Possiamo selezionare di utilizzare per ogni iterazione di test esattamente quelli che sono stati registrati oppure se associare quei parametri ad una sorta di dizionario (che andremo a creare) da cui VS sceglierà di volta in volta valori differenti.


Un altro aspetto interessante che possiamo personalizzare riguarda i "Request details". In questa finestra possiamo decidere se inserire dei "think time" tra le richieste (sostanzialmente dei ritardi) e, più importante, qual'è per noi il tempo "target" per le response. Se durante il test quella specifica richiesta avrà una response in un tempo maggiore di quello impostato come soglia, VS considererà il test come fallito.

Ora che abbiamo il webtest con tutti gli step ed i parametri impostati, possiamo finalmente aggiungere il progetto di Load Test alla nostra solution.


Il progetto di Load Test
Per aggiungere il test di carico ad un web performance test è sufficiente cliccare con il testo destro del mouse sul nome del progetto, scegliere "Add" e poi "Load test".


Quest'azione farà comparire il "Load test wizard" che ci guiderà nel setup del test di carico.

Nel primo step dobbiamo scegliere se e come gestire i "think times" (i ritardi tra le request): possiamo usare gli stessi think time acquisiti durante la registrazione (attenzione che se mentre registravamo, tra un click e l'altro abbiamo fatto una pausa di ad esempio 5 minuti, durante il test quei 5 minuti saranno settati come delay tra quelle due richieste), possiamo scegliere "normal distribution" (che fa una sorta di media tra i tempi di delay registrati) oppure proprio di non usarne. Possiamo anche inserire un tempo di attesa tra iterazioni diverse dello stesso test.

Nel secondo step dobbiamo decidere quanto carico vogliamo generare verso la nostra applicazione e le modalità di generazione.


Possiamo selezionare di avere un carico costante (il test inizierà cioè con N utenti e continuerà con lo stesso numero di utenti fino alla fine) o di effetturare un test con "step load".
Nell'immagine, ad esempio, ho deciso di utilizzare lo step load e di iniziare il test con 10 utenti aggiungendo ulteriori 10 utenti ogni 10 secondi, fino al raggiungimento di un massimo di 200 utenti.
Lo step load può essere molto interessante in quanto possiamo scoprire come (e se) la nostra applicazione scala in base all'incremento del carico applicativo.

Nello step successivo dobbiamo istruire il test di carico sul "cosa" fare. Per questa ragione inseriremo in questa schermata il web performance test che abbiamo creato precedentemente.



Cliccare su "Add", selezionare il performance test che vogliamo, cliccare su "Ok" ed il test sarà aggiunto nella finestra "test mix". Si chiama "Test Mix" perchè è possibile aggiungere quanti test vogliamo e se ne mettiamo più di uno possiamo definire la distribuzione percentuale di ognuno. In questo esempio abbiamo un solo test quindi la distribuzione sarà del 100%.

Possiamo anche decidere, negli step successivi, se e come utilizzare diversi tipi di connettività verso la nostra applicazione (attenzione: nel momento in cui scrivo VSO supporta solamente reti di tipo "LAN") e che tipo di browser engine vogliamo che siano utilizzati dai test agent per effettuare le richieste.


Come potete vedere nell'immagine, possiamo scegliere da un elenco di molti browser ed anche in questo caso possiamo definire la distribuzione percentuale.

Nell'ultimo step possiamo personalizzare la durata dell'esecuzione del test.


Possiamo scegliere tra un tempo fisso oppure un numero di iterazioni di test. Se selezioniamo un tempo fisso (nel mio esempio 2 minuti), possiamo anche impostare un "Warm-up time" (10 secondi nell'esempio). Durante questo tempo verranno inviate alcune richieste all'applicazione per "risvegliarla" e non saranno collezionati dati. Questo comportamento è estremamente utile se dobbiamo testare applicazioni che necessitano di un cold start (come ad esempio webapp hostate su IIS che magari non sono state usate per un periodo di tempo e per le quali quindi IIS ha "disattivato" l'AppPool) per non avere dei falsi positivi nel risultato del test.

Cliccando su "Finish", Visual Studio genererà il progetto di load test e lo salverà nella nostra soluzione.



Esecuzione del test
Ora che abbiamo tutto pronto possiamo eseguire il test. Ma prima, ancora un piccola impostazione. Noi vogliamo, infatti, che il test di carico sia eseguito attraverso la funzionalità Visual Studio Online Cloud Load Test ma nessuno l'ha detto al nostro Load Test project locale.

Per farlo bisogna aprire (doppo clic) il file "Local.testsettings" e cambiare il puntamento di "Test run location" su Visual Studio Online.


È da notare comunque che se abbiamo effettuato il login in Visual Studio con un account che ha una sottoscrizione a VSO questo step non sarà necessario in quanto VS seleziona direttamente questo valore per noi.

Ok, iniziamo il test cliccando sul bottone di start in alto a sinistra.


Ma cosa succede quando facciamo partire il test?
Visual Studio si connette a Visual Studio Online ed accoda il test. VSO poi crea on demand un lab virtual di test da qualche parte in un datacenter di Azure e configura i test agent sulle VM con i parametri settati.


Non appena il lab è pronto e configurato, il test parte. Se abbiamo configurato un periodo di warm up esso inizierà e potete vedere che non vengono collezionati dati.


Poi, finito il warm up, gli agenti iniziano a generare il traffico verso le pagine della nostra applicazione (così come utilizzate nella nostra registrazione) ed i risultati sono mandati al nostro Visual Studio quasi in tempo reale in modo da poter avere una preview del risultato finale del test.


Aspettiamo la fine del test per avere un resultset completo.


Risultati
Quando il test giunge al termine, verranno visualizzati tutti i risultati e le performance raggiunte. Le informazioni disponibili sono veramente moltissime.


Abbiamo i tempi di risposta medi, con anche il minimo ed il massimo, assieme ai tempi di test medi, i tempi di pagina medi ed il carico utente.

Possiamo vedere dal grafico e dalle info visualizzate che il numero di utenti virtuali è cresciuto nel tempo da 10 a 120 (avevo impostato un max di 200 ma non ha avuto tempo di raggiungere il massimo in quanto il test era limitato a soli 2 minuti con incrementi ogni 10 secondi) e come l'applicazione ha scalato al crescere del carico.

Anche nella sezione "Throughput" possiamo vedere molte informazioni utili.


In questo esempio non abbiamo avuto errori o parametri fuori soglia, ma se ci fossero stati avremmo visto un report degli stessi con le cause ed i messaggi di errore.

Questi sono però solo una piccola parte dei dati che abbiamo a disposizione. Se infatti clicchiamo sul link "download report" in alto, Visual Studio scaricherà l'intero resulset da Visual Studio Online rendendo disponibile, in questo modo, un report con una miriade di dati e grafici su ogni aspetto del test che ci aiuteranno a capire meglio come la nostra applicazione si comporta in uno scenario di carico.



Conclusioni
Questo tipo di Load test è il più completo che possiamo fare. Come potete vedere ci restituisce tantissime informazioni, metriche e grafici che ci permettono di analizzare il comportamento della nostra applicazione.
Inoltre, il setup di questi test è abbastanza semplice ma soprattutto è completamente personalizzabile ed in un poco tempo possiamo ottenere un gran numero di dati da poter consultare.

Il prossimo ed ultimo articolo di questa serie sarà sull'utilizzo delle Load Test APIs. Stay tuned! :)

lunedì 19 gennaio 2015

Cloud Load Test con Visual Studio Online - parte 1: Web panel

Questo articolo è il primo di una serie di 3 in cui parlerò di Cloud Load Testing con Visual Studio Online.

In questa prima parte affronterò l'esecuzione di test di carico semplici su applicazioni web, utilizzando direttamente le funzionalità messe a disposizione dal portale di VSO.

Introduzione
Prima di iniziare a parlare nello specifico dell'esecuzione dei Cloud Load Test è importante soffermarsi su alcuni aspetti.

  • Per poter utilizzare la funzionalità di Cloud Load Test è necessario avere una sottoscrizione MSDN Ultimate
  • L'applicazione da testare deve essere esposta sul web (al tool va indicato l'url da testare)
  • Gratuitamente si possono utilizzare fino a 15.000 minuti al mese. Si tratta di "virtual user minutes", quindi ad esempio eseguendo 1 test da 2 minuto con un carico costante di 200 virtual user si consumeranno 400 virtual user minutes.


Fatte queste precisazioni, vediamo come si possono eseguire i test di carico utilizzando l'iterfaccia presente sul portale di Visual Studio Online.


Iniziamo
Innanzitutto è necessario fare login al portale web di VSO e, dalla dashboard iniziale scegliere "Load test".


Fatto questo viene proposta la finestra di impostazione delle variabili del test. Come vedete si tratta di un unica schermata, quindi  le impostazioni possibili sono abbastanza limitate, ma comunque sufficienti a fare un test di carico generico sulla nostra applicazione.


Come prima cosa viene chiesto l'url su cui eseguire il test di carico: si tratta di un solo url (quindi non è possibile eseguire da qui un test di carico a step consecutivi o a navigazione pseudo-reale) che può corrispondere all'home page del sito o, come nell'esempio, ad una qualsiasi pagina della web application. L'unico vincolo presente è che la pagina deve essere visibile pubblicamente senza necessità di inserire delle credenziali, visto che al momento non è possibile impostarle.

Il secondo parametro da inserire è il nome del test: si tratta di una stringa libera, che servirà a noi solo come reminder.

Sotto questi due parametri ce ne sono altri 4, indicati proprio come "Test settings", che servono per poter meglio definire gli aspetti chiave del carico che si vuole applicare.

  • User Load: permette di definire il numero di utenti virtuali che contemporaneamente si collegheranno all'url fornito. I valori possibili sono 25, 50, 100 e 200
  • Run duration: è la durata complessiva del test. I valori selezionabili sono da 1 a 5 minuti
  • Think-time: si tratta del tempo di attesa tra una richiesta e l'altra. Serve per evitare che i sistemi di anti-hammering e anti DoS entrino in funzione. È possibile indicare tempi di attesa di 1 secondo (default) o 5 secondi
  • Browser distribution: questa impostazione indica la percentuale di utilizzo di browser che si vuole simulare. Scegliendo ad esempio "IE 80%, Chrome 20%" il test verrà eseguito con agenti useranno gli engine di Internet Explorer e di Chrome nelle percentuali selezionate


Settate queste impostazioni, cliccando sul bottone "Test now" si da inizio al test.


Esecuzione del Test
Ma cosa avviene, nel concreto quando si avvia il test?
Visual Studio Online crea per noi on demand un lab virtuale in un datacenter su Azure e configura gli agenti sulle vm con i parametri indicati:



Non appena il lab è pronto e configurato, inizia il vero e proprio test di carico. Gli agenti iniziano a generare traffico verso l'url indicato e i risultati sono inviati, quasi in real time, al nostro browser. In questo modo possiamo avere un'anteprima dell'esito del test.


In questa immagine vediamo, ad esempio, che intorno ai 50 secondi si è verificato "un buco" nelle richieste al secondo che il sito è risucito a gestire, testimoniato anche dal notevole incremento del tempo di risposta. Utilizzando questi dati potremmo avviare un'attività di analisi sulla nostra applicazione o sulla nostra infrastruttura per capire come mai si sia verificata un'anomalia del genere.


Risultati
Al completamento del test, ci vengono indicati gli esiti e le performance raggiunte.
Oltre al grafico che avevamo anche durante l'esecuzione ci vengono date altre informazioni.


Innanzitutto ci viene data l'indicazione tel tempo di risposta medio. Un tempo medio inferiore a 0,1 secondi è considerato buono. tra 1 secondo e 0,1 secondi è considerato "non molto buono", sopra il secondo è considerato negativo.

Dopo il tempo di risposta, è indicato il numero di richieste che in totale sono state fatte alla web app.

Infine, c'è l'indicazione delle eventuali richieste che non sono andate a buon fine o che hanno generato un errore sull'applicazione.

Sotto questi valori viene indicato anche quali errori sono stati riscontrati.


In questo caso non ve ne sono, se si fossero verificati degli errori nella tabella troveremmo la causa generica dell'errore, il suo tipo specifico ed il messaggio di errore.


Conclusioni
Questo tipo di Load test non è sicuramente il più completo che si possa ottenere, ma va comunque bene se ci interessa avere delle indicazioni di massima sulle prestazioni e sul carico supportato dalla nostra applicazione.
Inoltre il setup di questi test è estremamente semplice e in pochissimi minuti si è in grado di avere un gran numero di informazioni utili.

Se quello di cui avete bisogno, invece, è un test approfondito, eseguibile simulando un flusso reale di navigazione... non perdetevi il mio prossimo articolo di questa serie.

venerdì 19 dicembre 2014

Edit dei file di codice sorgente da Web con Visual Studio Online

Brian Harry, sul suo blog, ha annunciato il nuovo rilascio di Visual Studio Online; rilascio che comprende anche l'attesa funzionalità di editing del codice direttamente dal portale web.
Vediamo come funziona.
 
 
Edit
Dopo essere entrati sulla Dashboard del Team Project che vogliamo gestire, andiamo sulla sezione "Code" e selezioniamo dal menù ad albero di sinistra uno dei file di codice sorgente.
 
Sulla destra si aprirà, come al solito, la schermata in sola lettura che contiene il codice. A differenza di quanto succedeva precedentemente, però, è disponibile un nuovo bottone "Edit".
 
 
Cliccando sul bottone, succederanno tre cose:
  1. La toolbar cambierà visualizzazione
  2. Nel menu ad albero il file selezionato verrà "marcato" con un * ad indicare che è in modifica
  3. Nella schermata sarà possibile apportare modifiche al codice sorgente
 
 
Una volta completata la modifica, è possibile (consigliato, a dire il vero...) inserire un commento nella textbox che verrà associato al checkin e premere sul pulsante di salvataggio (comparso nella toolbar).
 
Cliccato su "Save", la modifiche vengono salvate sul source control, viene creato un changeset e viene visualizzato un tooltip che ci informa dell'esito positivo dell'operazione, con un link alla visualizzazione del changeset stesso.
 
 
È anche possibile annullare le modifiche utilizzando il bottone "Discard", sempre nella toolbar.
Infine, se prima di fare il checkin vogliamo verificare le modifiche apportate, è possibile fare una diff tra il file residente sul source control e la nostra versione, utilizzando il pulsante all'estrema destra della toolbar.
 
 
  
Upload, Create, Rename, Delete
Oltre a modificare direttamente i sorgenti, è possibile anche rinominare, cancellare e creare file e cartelle e fare l'upload di nuovi file.
 
 
Per creare un nuovo file o farne l'upload basta cliccare con il tasto destro su una cartella e scegliere "Add file(s)".
Si aprirà un popup in cui si può scegliere se creare un file nuovo o se scegliere dei file già esistenti da caricare.
 
 
Viceversa, per cancellare un file cliccarci sopra con il tasto destro e scegliere "Delete" (viene chiesta conferma).
 
Per rinominarlo, infine, sempre dal menù contestuale che appare con il tasto destro scegliere "Rename".
 
Tutte queste operazioni genereranno un changeset, quindi le modifiche saranno mappate e storicizzate sul source control.

mercoledì 12 novembre 2014

Aggiungere Azure Application Insights ad un Web Site

Sviluppando una Web Application, è possibile usare Visual Studio 2013.3 per aggiungere automaticamente tutte le librerie e le configurazioni di cui "Azure Application Insights" ha bisogno pre funzionare.
 
Ma invece per quanto riguarda i Web Sites? Se si crea un Web Site (oppure si vuole modificarne o gestirne uno già esistente) l'opzione per aggiungere l'Application Insights non è presente. Cosa possiamo fare, quindi? Com'è possibile raggiungere lo stesso risultato? Come possiamo integrare Azure Application Insights in un Web Site?
 
È possibile! Basta seguire questi step:
  1. Creare un nuovo servizio "Application Insights" usando il nuovo Azure portal (preview)
  2. Copiare lo snippet di codice JavaScript che viene proposto dal portale ed aggiungerlo a tutte le pagine che si vogliono monitorare (oppure alla master page, se ce n'è una)
  3. In Visual Studio 2013.3, creare una nuova web application vuota ed aggiungere ad essa Application Insights usando il menu contestuale
  4. Copiare i seguenti file dalla cartella "bin" della Web App alla cartella "bin" del Web Site:
    Microsoft.ApplicationInsights.dll
    Microsoft.ApplicationInsights.Extensibility.RuntimeTelemetry.dll
    Microsoft.ApplicationInsights.Extensibility.Web.dll
    Microsoft.Diagnostics.Tracing.EventSource.dll
    (volendo è possibile anche copiare i relativi file .xml e .pdb)
    
  5. Tornare nell'Azure portal (preview), andare nella sezione dell'Application Insights creato precedentemente, cliccare sul bottone "Properties" e copiare il valore della texbox "Instrumentation Key"
  6. Copiare il file ApplicationInsights.config dalla root della Web App alla root folder del Web Site
  7. In questo file, sostituire il valore della chiave "InstrumentationKey" con quello copiato al punto 5
  8.  Cambiare il file web.config del website aggiungendo le seguenti righe:
    <system.web>
     [...]
        <httpModules>
       [...]
          <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Extensibility.Web.RequestTracking.WebRequestTrackingModule, Microsoft.ApplicationInsights.Extensibility.Web" />
       [...]
        </httpModules>
     [...]
    </system.web>
    
    <system.webServer>
     [...]
        <validation validateIntegratedModeConfiguration="false" />
     [...]
     <modules runAllManagedModulesForAllRequests="true">
       [...]
          <remove name="ApplicationInsightsWebTracking" />
          <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Extensibility.Web.RequestTracking.WebRequestTrackingModule, Microsoft.ApplicationInsights.Extensibility.Web" preCondition="managedHandler" />
       [...]
        </modules> 
     [...]
    </system.webServer> 
    
 
A questo punto è possibile avviare e testare il Web Site e, dopo qualche secondo, i dati e le statistiche saranno presenti nella blade dell'Application Insights (sempre sul nuovo Azure portal)

martedì 11 novembre 2014

Gestire i Cloud Load Test con le REST API

Le REST API dei Cloud-based Load Testing (CLT) permettono di automatizzare l'esecuzione dei Load test dal Cloud, in modo da poterli integrare nei processi di Continuous Integration / Deployment e di Test Automation.

Ecco una lista (sicuramente in espansione) di quello che si può fare con queste nuove API:
  • Creare / Lanciare / Stoppare un Load Test Run
  • Recuperare i Load Test Results - un set di gruppi di  KPI - Performance, Throughput, Application
  • Recuperare i Messages del servizio durante l'esecuzione
  • Recuperare le Exceptions, se ci sono
  • Recuperare le Counter instances di un  Load Test run
  • Recuperare gli Application Counters delle App configurate nel load test
  • Recuperare una lista di tutti i Load test Runs eseguiti - con filtri per requester, date, status ecc..
Queste API lavorano in stretta vicinanza con le Azure API, visto che si leggono i test file da un Azure Blob e salvano i risultati nella stessa drop folder sempre sull'Azure Blob.

È importante notare che:
  • Per usare le REST API, è necessario abilitare le alternate credentials su Visual Studio Online e quindi utilizzarle per l'autenticazione
  • Aggiungere"vsclt" al nome dell'account VSO per essere rediretti al "Cloud-based Load Test (CLT) service" di visualstudio.com. Ade sempio, se l'account è https://abc.visualstudio.com/, quando si utilizzano le API indicare https://abc.vsclt.visualstudio.com/
 
Il pattern di base per le  API è il seguente:
VERB    https://{account}.vsclt.visualstudio.com/_apis/clt/{resource}[/{options}]
 
Dove "resource" può essere una delle seguenti e le "options" dipendono dalla resource:
 
Test
  • Per i "Test Runs": testruns
  • Per le "Test Drops" (i container dove vengono salvati i dati): testdrops
 
Dipendenti dai Test Run
  • Per le "Counter Instances": testruns/{testrunid}/counterinstances
  • Per i "Counter Samples": testruns/{testrunid}/countersamples
 
Application Performance Management:
  • Per i "APM Plugins": apm/plugins
  • Per le "APM Applications ": apm/applications
  • Per i "APM Counters ": apm/counters

Creare un Test Run
Per creare un Cloud Load Test Run, è necessario fare una chiamata POST alle API, passando nel body un set di parametri e test settings come in questo esempio.

Request Url:
POST    https://dbtek.vsclt.visualstudio.com/_apis/clt/testruns

Request Body:
{
  "name": "MyAppToTest.loadtest",
  "description": "nightly loadtest",
  "testSettings": {
    "cleanupCommand": "",
    "hostProcessPlatform": "x86",
    "setupCommand": ""
  },
  "testDrop": {
    "id": "fe35ed32-eaab-4178-ba7e-ad2577ee187f"
  }
}


Response:
{
  "id": "a5e0d4b9-d387-4b3e-9566-163da9c39b67",
  "name": "MyAppToTest.loadtest",
  "createdDate": "2014-11-1T08:51:27.0965365Z",
  "state": "pending",
  "subState": "none",
  "testSettings": {
    "cleanupCommand": "",
    "hostProcessPlatform": "x86",
    "setupCommand": ""
  },
  "testDrop": {
    "id": "fe35ed32-eaab-4178-ba7e-ad2577ee187f",
    "url": "https://dbtek.vsclt.visualstudio.com/_apis/clt/TestDrops/fe35ed32-eaab-4178-ba7e-ad2577ee187f"
  },
  "runSpecificDetails": {
    "duration": 180,
    "virtualUserCount": 250,
    "samplingInterval": 15
  },
  "createdBy": {
    "id": "76cabfe4-0e20-4f5b-862e-9693a68232f1",
    "displayName": "iamtheuser@dbtek.it"
  },
  "url": "https://dbtek.vsclt.visualstudio.com/_apis/clt/testruns/a5e0d4b9-d387-4b3e-9566-163da9c39b67"
}


Come si può vedere, nella response si trovano tutti i dati che possono servire relativi al test run appena creato.

Avviare un Test Run
Con questi dati possiamo per esempio avviare (o meglio accodare) il test run, chiamando le API usando un verb PATCH:

Request Url:
PATCH    https://dbtek.vsclt.visualstudio.com/_apis/clt/testruns/a5e0d4b9-d387-4b3e-9566-163da9c39b67

Request Body:
{
  "state": "queued"
}


Response:
Status code: 202


Recuperare i Test results
Infine, quando il test è finito, possiamo recuperare i risultati con una call in GET.

Request Url:
GET    https://dbtek.vsclt.visualstudio.com/_apis/clt/testruns/a5e0d4b9-d387-4b3e-9566-163da9c39b67/results

Response:
{
  "resultsUrl": "http://127.0.0.1:10000/devstoreaccount1/ets-containerfor-aeee0697-d734-43d7-956e-e662252c265c/2150fbd4-e71c-42fd-8b90-95222a556d87/TestResult/LoadTest.ltrar.zip?sv=2012-02-12&se=2014-06-03T05%3A05%3A39Z&sr=b&si=sas_tenant_policyaeee0697-d734-43d7-956e-e662252c265c&sig=n1Tj%2BsCtiOqQu9UtcXsl%2Bn3ixP%2FVebHCKDJvfD5Tr%2FE%3D",
  "counterGroups": {
    "count": 3,
    "value": [
      {
        "groupName": "Performance",
        "url": "https://dbtek.vsclt.visualstudio.com/_apis/clt/testruns/a5e0d4b9-d387-4b3e-9566-163da9c39b67/CounterInstances?groupNames=Performance"
      },
      {
        "groupName": "Throughput",
        "url": "https://dbtek.vsclt.visualstudio.com/_apis/clt/testruns/a5e0d4b9-d387-4b3e-9566-163da9c39b67/CounterInstances?groupNames=Throughput"
      },
      {
        "groupName": "Application",
        "url": "https://dbtek.vsclt.visualstudio.com/_apis/clt/testruns/a5e0d4b9-d387-4b3e-9566-163da9c39b67/CounterInstances?groupNames=Application"
      }
    ]
  }
}



Recuperare i Test errors
È anche possibile recuperare una lista di eventuali errori che si sono verificati durante l'esecuzione del test. Di nuovo, va utilizzata una chiamata in GET.

Request Url:
GET    https://dbtek.vsclt.visualstudio.com/_apis/clt/testRuns/47be20f0-ac4a-40cd-acb7-d9f8c44d0404/Errors

Response:
{
  "count": 2,
  "value": [
    {
      "type": "Exception",
      "subType": "UriFormatException",
      "occurrences": 50,
      "testCaseName": "ErrorsAndExceptionsWebTest",
      "scenarioName": "LoadTestingScenarioWarmupDuration",
      "request": "http://www.bing:123.com/----{GET}",
      "stackTrace": "   at System.Uri.CreateThis(String uri, Boolean dontEscape, UriKind uriKind)\n   at System.Uri..ctor(String uriString, Boolean dontEscape)\n   at Microsoft.VisualStudio.TestTools.WebStress.WebTestTransaction..ctor(String requestUrl)\n   at Microsoft.VisualStudio.TestTools.WebStress.WebTestInstrumentedTransaction.CreateTransaction()\n   at Microsoft.VisualStudio.TestTools.WebStress.WebTestInstrumentedTransaction.Execute(WebTestCaseContext testCaseContext, AsyncCallback completionCallback, Object callerState)",
      "messageText": "Invalid URI: Invalid port specified.",
      "lastErrorDate": "2014-11-11T09:14:20.363Z"
    },
    {
      "type": "ExtractionRuleError",
      "subType": "ExtractText",
      "occurrences": 50,
      "testCaseName": "ErrorsAndExceptionsWebTest",
      "scenarioName": "LoadTestingScenarioWarmupDuration",
      "request": "http://www.bing.com/----{GET}",
      "stackTrace": "",
      "messageText": "StartsWith text was not found in the response",
      "lastErrorDate": "2014-11-11T09:14:23.663Z"
    }
  ]
}

giovedì 30 ottobre 2014

Mettere il Database sotto Source Control - eBook gratuito

Normalmente, un sistema di Source e Version control mostra enormi benefici nel coordinamento del lavoro dei team di sviluppo, garantendo un audit trail completo di tutte le modifiche ai file di codice e permettendo alla squadra di tenere traccia di qualsiasi versione specifica o build.

Anche gli sviluppatori di database possono (e dovrebbero...) trarre beneficio dal audit history e dalle funzionalità di change-tracking, c'è molto di più che salvare qualche script DB in una sottocartella dell'applicazione sul sistema di source control. A differenza di chi sviluppa applicazioni, i database developers non assemblano file e classi in un pacchetto applicativo, ma invece eseguono script che magari si alimentano a vicenda o da altri oggetti esistenti instaurando una stretta interdipendenza tra il codice ed i dati.

Per coprire quello che possiamo chiamare "Database Lifecycle Management", e considerare un ramo dell'ALM, RedGate ha sviluppato un interessante ebook gratuito, dal nome "SQL Server Source Control Basics".

Purtroppo, gli autori del libro hanno deciso di utilizzare SVN, ma i concetti chiave si possono applicare senza problami anche a Team Foundation Server o Visual Studio Online.

Tra gli argomenti trattati ci sono:
Concetti fondamentali dei sistemi di source control
Scegliere un sistema di version control per il database e definirne la struttura
Strategie di branch e merge
Automatizzare il versionamento del database ed il suo deployment
Introduzione al "Database continuous integration"

L'eBook offre una guida dettagliata sui concetti di Database source control con esempi chiari e completi.

Può essere scaricatoto, gratis, qui (disponibile solo in lingua inglese):

martedì 28 ottobre 2014

Visual Studio Online REST API versione 1.0

Oggi è stata rilasciata la prima versione ufficiale delle REST API di Visual Studio Online, la 1.0.

Annunciate in preview in maggio, ora hanno raggiunto una maturità tale da spingere il team di sviluppo a chiudere la prima release. Questo non significa che non ci saranno cambiamenti o che gli sviluppi siano terminati; significa che le funzionalità core sono ora complete e da qui in avanti verranno versionate per mantenere  la compatibilità all'indietro, in modo che tutte le applicazioni ed i servizi che le utilizzano rimangano comunque funzionanti a prescindere dagli aggiornamenti futuri.

Congiuntamente all'annuncio, il team ha modificato il "API Reference portal" e la "Getting started guide"

Importante
Se avete delle applicazioni esistenti che utilizzano la versione 1.0 preview delle API, dovreste iniziare la migrazione alla  release 1.0 prima possibile; infatti la versione 1.0 preview (e precedenti) smetteranno di funzionare in 12 settimane da oggi. Per sapere di più sul versioning e sulla migrazione è possibile consultare la "versioning and migration page".

Detto questo, ricordate che a partire da oggi, quindi, le Visual Studio Online REST API seguono questo pattern:

VERB https://{account}.VisualStudio.com/DefaultCollection/_apis[/{area}]/{resource}?api-version=1.0

lunedì 13 ottobre 2014

Integrare un’applicazione o un servizio con Visual Studio Online - Guest Post MSDN

Venerdì scorso è stato pubblicato su MSDN Italia il mio secondo Guest post, in cui parlo di com'è possibile e facile integrare le nostre applicazioni e servizi con Visual Studio Online utilizzando le nuove REST API ed i Service Hooks.

Per leggere l'articolo completo utilizzare il link sottostante:

lunedì 6 ottobre 2014

Migrare facilmente da Team Foundation Server a Visual Studio Online - Guest Post MSDN

Oggi è stato pubblicato su MSDN Italia un mio Guest post in cui spiego come effettuare la migrazione da un Team Foundation Server (quindi normale scenario di installazione on-premises) al suo corrispettivo on-cloud Visual Studio Online e quali sono le motivazioni che potrebbero spingerci a farlo.

Per leggere il post utilizzare il link sottostante:

martedì 30 settembre 2014

Creare un Work Item con le REST API - Visual Studio Online

A volte può essere utile aggiungere un nuovo Work Item ad un nostro Team Project in modo automatico, magari in risposta ad un determinato evento.

Le nuove "WIT REST API v1.0 (preview 2)" (rilasciate il 4 settembre) esposte da Visual Studio Online ci permettono di farlo.

Quando creiamo un work item, possiamo indicare i valori per qualsiasi tipo di work item fields.

Per creare un work item, è necessario effettuare una richiesta HTTP PATCH a:

https://your_account.visualstudio.com/defaultcollection/team_project_name/_apis/wit/workitems/$work_item_type_name?api-version=1.0-preview.2

Il body della richiesta deve essere valorizzato in base a questo formato:

[
    {
        "op": "add",
        "path": { string }
        "value": { string or int, depending on the field }
    },
    {
        "op": "add",
        "path": "/relations/-",
        "value":
        {
            "rel": { string },
            "url": { string },
            "attributes":
            {
                { name/value pairs }
            }
        }
    }
]

Un esempio di richiesta potrebbe essere:

https://myAccount.visualstudio.com/defaultcollection/myProject/_apis/wit/workitems/$task?api-version=1.0-preview.2

[
  {
    "op": "add",
    "path": "/fields/System.Title",
    "value": "Change blog title height"
  }
]

Questa richiesta produce una response come la seguente, in cui si possono trovare tutte le informazioni relative al work item appena creato:

{
  "id": 88,
  "rev": 1,
  "fields": {
    "System.AreaPath": "myProject",
    "System.TeamProject": "myProject",
    "System.IterationPath": "myProject",
    "System.WorkItemType": "Task",
    "System.State": "To Do",
    "System.Reason": "New task",
    "System.CreatedDate": "2014-09-30T10:25:12.943Z",
    "System.CreatedBy": "Davide Benvegnu",
    "System.ChangedDate": "2014-09-30T10:25:12.943Z",
    "System.ChangedBy": "Davide Benvegnu,
    "System.Title": "Change blog title height"
  },
  "_links": {
    "self": {
      "href": "https://myAccount.visualstudio.com/DefaultCollection/_apis/wit/workItems/88"
    },
    "workItemUpdates": {
      "href": "https://myAccount.visualstudio.com/DefaultCollection/_apis/wit/workItems/88/updates"
    },
    "workItemRevisions": {
      "href": "https://myAccount.visualstudio.com/DefaultCollection/_apis/wit/workItems/88/revisions"
    },
    "workItemHistory": {
      "href": "https://myAccount.visualstudio.com/DefaultCollection/_apis/wit/workItems/88/history"
    },
    "html": {
      "href": "https://myAccount.visualstudio.com/web/wi.aspx?pcguid=0fa87894-6f48-4458-957d-3438b6bb9343&id=88"
    },
    "workItemType": {
      "href": "https://myAccount.visualstudio.com/DefaultCollection/c4637008-2068-4b3f-828d-a214e2ba5210/_apis/wit/workItemTypes/Task"
    },
    "fields": {
      "href": "https://myAccount.visualstudio.com/DefaultCollection/_apis/wit/fields"
    }
  },
  "url": "https://myAccount.visualstudio.com/DefaultCollection/_apis/wit/workItems/88"
}