Test delle unità usando Jasmine e TypeScript

Question

Sto provando a ottenere un test unitario scritto in Typescript usando Jasmine per compilare. Con quanto segue nel mio file di test unitario, Resharper mi richiede un link per importare i tipi da jasmine.d.ts.

/// <reference path="sut.ts" /> 
/// <reference path="../../../scripts/typings/jasmine/jasmine.d.ts" /> 

describe("Person FullName", function() { 
    var person; 

    BeforeEach(function() { 
     person = new Person(); 
     person.setFirstName("Joe"); 
     person.setLastName("Smith"); 
    }); 

    It("should concatenate first and last names", function() { 
     Expect(person.getFullName()).toBe("Joe, Smith"); 
    }); 
}); 

Così clicco sul link e finire con il seguente (in realtà ReSharper preceduto solo la funzione di descrivere con, così ho prefissati manualmente l'altra Jasmine chiama "Jasmine".):

/// <reference path="sut.ts" /> 
/// <reference path="../../../scripts/typings/jasmine/jasmine.d.ts" /> 
import Jasmine = require("../../../Scripts/typings/jasmine/jasmine"); 

Jasmine.describe("Person FullName", function() { 
    var person; 

    Jasmine.BeforeEach(function() { 
     person = new Person(); 
     person.setFirstName("Joe"); 
     person.setLastName("Smith"); 
    }); 

    Jasmine.It("should concatenate first and last names", function() { 
     Jasmine.Expect(person.getFullName()).toBe("Joe, Smith"); 
    }); 
}); 

Tuttavia, la dichiarazione di importazione presenta una linea ondulata rossa con il messaggio di errore "Impossibile risolvere il modulo esterno ../../../scripts/typings/jasmine/jasmine. Il modulo non può essere alterato in un tipo non modulo"

Qualche idea su cosa sta causando questo errore? Ho verificato che l'opzione "Sistema di moduli" è impostata su AMD nelle impostazioni di configurazione del mio progetto. Ho anche controllato che il modulo jasmine sia definito in jasmine.d.ts. Ho scaricato questo file dal sito DefinitelyTyped.

declare module jasmine { 
    ... 
} 

Answer 1

Includere questo al vostro file html gelsomino, ...

<script type="text/javascript" src="jasmine/lib/jasmine-2.0.0/jasmine.js"></script> 

... o installare il pacchetto NPM gelsomino:

npm install --save-dev jasmine 

quando si utilizza la seconda strada (gelsomino come modulo) devi importarlo:

var jasmine = require('jasmine'); 

o

import jasmine from 'jasmine'; 

quindi modificare l'altro codice:

jasmine.describe("Person FullName", function() { 
    var person; 

    jasmine.beforeEach(function() { 
     person = new Person(); 
     person.setFirstName("Joe"); 
     person.setLastName("Smith"); 
    }); 

    jasmine.it("should concatenate first and last names", function() { 
     jasmine.expect(person.getFullName()).toBe("Joe, Smith"); 
    }); 
}); 

Personalmente preferirei il primo modo senza utilizzare il modulo di gelsomino NPM. (Non ho la prova ancora il modulo)

Answer 2

Per quanto mi riguarda ho fatto la seguente:

Installare Tipizzazioni

npm install typings --global 

quindi aggiungere le tipizzazioni a gelsomino

typings install dt~jasmine --save --global 

Answer 3

Metti questa nella parte superiore del file spec dattiloscritto:

/// <reference path="../../node_modules/@types/jasmine/index.d.ts" /> 
let Jasmine = require('jasmine'); 

È necessario installare i seguenti moduli Jasmine per quella di lavorare:

$ npm install jasmine-core jasmine @types/jasmine jasmine-ts --save-dev 

Una volta fatto questo, l'IDE (come WebStorm) riconoscerà Jasmine e le sue funzioni, come descritto(), esso(), e expect() .. Quindi non è necessario prefisso con "Jasmine". Inoltre, puoi eseguire i tuoi file spec dalla riga di comando usando il modulo jasmine-ts. Installare questi strumenti da riga di comando a livello globale:

$ npm install -g jasmine jasmine-ts 

quindi configurare il modulo di riga di comando "gelsomini" in modo che Jasmine può trovare il suo file di configurazione.Poi si dovrebbe essere in grado di eseguire il gelsomino-ts e il file spec dovrebbe funzionare bene dalla riga di comando:

./node_modules/.bin/jasmine-ts src/something.spec.ts 

.. e, è possibile configurare il vostro IDE per eseguirlo così pure, ed eseguire il debug corre che anche il modo dovrebbe funzionare (funziona per me).

Scrivendo i test in questo modo, è possibile eseguire una specifica di test Jasmine sul lato server senza Karma o eseguirla in un browser Web utilizzando Karma. Lo stesso codice dattiloscritto.

Answer 4

Per qualche motivo questo non ha mai avuto una risposta adeguata, ovviamente le cose sono cambiate ma non esiste una risposta moderna qui, sono venuto qui attraverso Google perché sono pigro e io a volte qualche frammento di google.

Nel caso in cui si verifichi questo problema, assicurarsi di avere @typings/jasmine installato come devDependency e il proprio tsConfig contenga le tipizzazioni incluse per es.

"include": ["typings/**/*.d.ts"] 

Answer 5

Ecco (a mio parere) il modo migliore per testare un'applicazione ts-node come del 2018:

npm install --save-dev jasmine @types/jasmine ts-node 

In package.json:

{ 
    "scripts": { 
    "test": "ts-node node_modules/jasmine/bin/jasmine" 
    } 
} 

nei file spec:

import "jasmine"; 
import something from "../src/something"; 

describe("something",() => { 
    it("should work",() => { 
     expect(something.works()).toBe(true); 
    }); 
}); 

Per eseguire i test:

npm test 

Questo userà le versioni installate localmente di ts-node e jasmine. È meglio che utilizzare versioni installate globalmente, perché con le versioni locali, puoi essere sicuro che tutti utilizzano la stessa versione.

Nota: se si dispone di un'app Web anziché di un'app di nodo, è consigliabile eseguire i test utilizzando Karma anziché la CLI di Jasmine.

Answer 6

Se avete problemi con le importazioni, utilizzare tsconfig-paths

npm i ts-node tsconfig-paths types/jasmine jasmine --save-dev 

Run dattiloscritto-enabled gelsomino:

ts-node -r tsconfig-paths/register node_modules/jasmine/bin/jasmine.js 

Assicurarsi che il gelsomino cercherà i file Ts:

"spec_files": [ 
    "**/*[sS]pec.ts" 
], 
"helpers": [ 
    "helpers/**/*.ts" 
], 

Per testare i tuoi script potresti aver bisogno anche di polyfill se li usi nel tuo progetto. Creare un file di supporto con importazioni richieste, come helpers/global/polifill.ts

import 'core-js';