Come posso fornire valori di dati campione riutilizzabili ai miei test di unità angularjs/jasmine

Question

Vorrei fornire semplici valori costanti come nomi, e-mail, ecc. Da utilizzare nei miei test di unità di gelsomino.

Una domanda simile è stato chiesto qui: AngularJS + Karma: reuse a mock service when unit testing directives or controllers

In C# vorrei creare una classe statica per contenere piccoli frammenti di dati di finte. Posso quindi utilizzare questi valori durante i miei test di unità, in questo modo:

static class SampleData 
{ 
    public const string Guid = "0e3ae555-9fc7-4b89-9ea4-a8b63097c50a"; 
    public const string Password = "3Qr}b7_N$yZ6"; 

    public const string InvalidGuid = "[invalid-guid]"; 
    public const string InvalidPassword = "[invalid-password]"; 
} 

Vorrei avere la stessa comodità quando si prova la mia app AngularJS utilizzando Karma/Jasmine.

So che posso definire un oggetto constant contro la mia app angolare, ho già fare questo per le costanti che uso nel codice vero e proprio, in questo modo:

myApp.constant('config', {apiUrl:'http://localhost:8082'}) 

potrei aggiungere un'altra costante, proprio come questo, ma solo contenente i valori dei dati campione per l'uso in mio test di unità, in questo modo:

myApp.constant('sampleData', {email: 'sample@email.com'}) 

ho potuto quindi solo iniettare oggetto costante finto nei test e via andare, come questo

describe 'A sample unit test', -> 
    beforeEach -> module 'myApp' 
    beforeEach inject ($injector) -> 
     @sampleData = $injector.get 'sampleData' 
     email = @sampleData.email 
     # etc ... 

Tuttavia questo mi sembra un po 'strano. Non voglio che il mio codice di produzione contenga dati campione che sono richiesti solo dai miei test unitari.

In che modo forniresti comodamente i test di unità angolari/gelsomino con valori di dati campione riutilizzabili?

Grazie

Answer 1

Ci sono due modi per farlo:

• spiare le chiamate di funzione e restituiscono valori falsi.
• creare classi finte (e possibilmente i dati finte per inizializzare loro) e caricarli ovunque è necessario

Il primo è bene quando si hanno solo finto un paio di telefonate. farlo per un'intera classe è insostenibile.

Ad esempio, supponiamo che tu abbia un servizio che crea alcuni URL speciali. Se uno dei metodi dipende absUrl, si può fingere spiando sul metodo nell'oggetto $location:

describe('example') function() { 
    beforeEach(inject(function() { 
     spyOn($location, 'absUrl').andCallFake(function (p) { 
      return 'http://localhost/app/index.html#/chickenurl'; 
     }); 
    })); 
it('should return the url http://www.chicken.org') ... { 
    // starting situation 
    // run the function 
    // asserts 
} 

Ora diciamo che avete un servizio Settings che incapsula i dati, come la lingua, a tema, percorsi speciali, colore di sfondo, carattere tipografico ... che viene inizializzato utilizzando una chiamata remota a un server. I servizi di verifica che dipendono da Settings saranno dolorosi. Devi prendere in giro un grosso componente con spyOn ogni volta. Se hai 10 servizi ... non vuoi copiare le funzioni di spyOn in tutti loro.

ServiceA utilizza Settings servizio:

describe('ServiceA', function() { 
var settings, serviceA; 

beforeEach(module('myapp.mocks.settings')); // mock settings 
beforeEach(module('myapp.services.serviceA')); // load the service being tested 

beforeEach(inject(function (_serviceA_, _settings_) { 
    serviceA = _serviceA_; 
    settings = _settings_; 
})); 

contenitore per questa suite di test, tutte le chiamate al servizio di Settings saranno gestite dal finto, che ha la stessa interfaccia del reale, ma restituisce valori fittizi . Si noti che è possibile caricare questo servizio ovunque.

(Se, per qualsiasi motivo, è necessario utilizzare l'attuazione reale, è possibile caricare l'attuazione reale prima che il finto e utilizzare spyOn per quel caso specifico di delegare la chiamata alla vera realizzazione.)

Normalmente posizionerai il modulo mock al di fuori della cartella dell'app. Ho una cartella test con i test delle unità, i test e2e e una cartella lib con il file angular-mocks.js. Lì metto anche le mie mamme. Dillo karma i file necessari per le prove:

files: [ 
     'app/lib/jquery/jquery-1.9.1.js', 
     'test/lib/jasmine-jquery.js', 
     'app/lib/angular/angular.js', 
     'app/lib/angular/angular-*.js', 
     'test/lib/angular/angular-mocks.js', 
     'test/lib/myapp/*.js', /* this is mine */ 
     'app/js/**/*.js', 
     'test/unit/**/*.js' 
    ], 

Il file tests/lib/myapp.mocks.settings.js sembra proprio come qualsiasi altro modulo:

(function() { 
"use strict"; 

var m = angular.module('myapp.mocks.settings', []); 

m.service('settings', function() { ... }) 
}) 

Secondo problema (opzionale): si desidera modificare rapidamente i valori fittizi. Nell'esempio, il servizio impostazioni recupera un oggetto dal server quando viene istanziato per la prima volta. quindi, il servizio ha getter per tutti i campi. Questa è una specie di proxy per il server: invece di inviare una richiesta ogni volta che hai bisogno di un valore, prendine un mucchio di questi e salvali localmente. Nella mia applicazione, le impostazioni non cambiano nel server in fase di esecuzione.

Qualcosa di simile:

1. fetch http://example.org/api/settings 
2. var localSettings = fetchedSettings; 
3 getFieldA: function() { return localSettings.fieldA; } 

Go e inquina l'namespace globale. Ho creato un file settings.data.js con un contenuto simile:

var SETTINGS_RESPONSE = { fieldA: 42 }; 

il servizio finto utilizza questa variabile globale in fabbrica per istanziare localSettings