webentwicklung-frage-antwort-db.com.de

Unit-Tests mit Jasmine und TypeScript

Ich versuche, einen Komponententest in TypeScript zu erstellen, der Jasmine zum Kompilieren verwendet. Mit dem Folgenden in meiner Unit-Test-Datei fordert Resharper mich mit einem Link zu Importtypen aus jasmine.d.ts auf. 

/// <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");
    });
});

Also klicke ich auf den Link und ende mit dem Folgenden (eigentlich wurde die Beschreibungsfunktion eigentlich nur mit "Jasmine" vor der Beschreibungsfunktion vorangestellt, also habe ich die anderen Jasmine-Aufrufe manuell vorangestellt):

/// <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");
    });
});

Die import-Anweisung hat jedoch eine rote, verschnörkelte Zeile mit der Fehlermeldung "Externes Modul kann nicht aufgelöst werden ../../../scripts/typings/jasmine/jasmine. Das Modul kann nicht auf einen Nicht-Modultyp festgelegt werden."

Irgendeine Idee, was diesen Fehler verursacht? Ich habe überprüft, dass die Option "Modulsystem" in meinen Projekterstellungseinstellungen auf AMD eingestellt ist. Ich habe auch überprüft, dass das Jasmin-Modul in Jasmin.d.ts definiert ist. Ich habe diese Datei von der DefinitelyTyped-Site heruntergeladen.

declare module jasmine {
    ...
}
31
aw1975

Hier ist (meiner Meinung nach) der beste Weg, um eine ts-node - App ab 2018 zu testen:

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

In package.json:

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

In Ihren Spezifikationsdateien:

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

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

So führen Sie die Tests durch:

npm test

Dies verwendet die lokal installierten Versionen von ts-node Und jasmine. Dies ist besser als die Verwendung global installierter Versionen, da Sie bei lokalen Versionen sicher sein können, dass alle Benutzer dieselbe Version verwenden.

Hinweis: Wenn Sie eine Web-App anstelle einer Node-App haben, sollten Sie Ihre Tests wahrscheinlich mit Karma anstelle der Jasmine-CLI ausführen.

42
AJ Richardson

Fügen Sie dies oben in Ihre TypeScript-Spezifikationsdatei ein:

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

Damit dies funktioniert, müssen Sie die folgenden Jasmine-Module installieren:

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

Sobald Sie das getan haben, erkennt die IDE (wie WebStorm) Jasmine und seine Funktionen wie zum Beispiel (beschreiben (), it () und expect ()). Sie müssen also nicht "Jasmine" voranstellen . " Sie können Ihre Spec-Dateien auch von der Befehlszeile aus mit dem Modul Jasmin-ts ausführen. Installieren Sie diese Befehlszeilentools global:

$ npm install -g jasmine jasmine-ts

Konfigurieren Sie dann das Befehlszeilenmodul "Jasmin", damit Jasmine seine Konfigurationsdatei finden kann. Dann sollten Sie in der Lage sein, Jasmin-ts auszuführen, und Ihre Spezifikationsdatei sollte problemlos von der Befehlszeile aus ausgeführt werden:

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

.. und Sie können Ihre IDE so konfigurieren, dass sie auch so ausgeführt wird, und Debug-Läufe auf diese Weise sollten ebenfalls funktionieren (funktioniert für mich).

Wenn Sie Ihre Tests auf diese Weise schreiben, können Sie eine Jasmin-Testspezifikation auf dem Server ohne Karma oder in einem Webbrowser mit Karma ausführen. Gleicher TypeScript-Code.

7
Yavin5

Für mich habe ich folgendes gemacht:

Installieren Sie Typings

npm install typings --global

Dann fügen Sie die Typisierung für Jasmin hinzu

typings install dt~jasmine --save --global
5
Andrew Newland

Fügen Sie dies Ihrer Jasmin-HTML-Datei hinzu, ...

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

... oder installieren Sie das npm jasmine-Paket:

npm install --save-dev jasmine

wenn Sie den zweiten Weg (Jasmin als Modul) verwenden, müssen Sie ihn importieren:

var jasmine = require('jasmine');

oder

import jasmine from 'jasmine';

dann ändern Sie den anderen Code:

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");
    });
});

Persönlich würde ich den ersten Weg ohne das Jasmin-npm-Modul vorziehen. (Ich habe das Modul noch nicht getestet)

3
marcel

Sie könnten versuchen, einen Nebeneffekt nur zu importieren , der die @types/jasmine-Deklaration einbringt und die Jasmin-Funktionen in den globalen Gültigkeitsbereich einfügt, so dass Sie nicht jeden Aufruf mit jasmine. voranstellen müssen, um einen schnellen Port von vorhandenen Unit-Tests zu ermöglichen spielt nett mit webpack.

// tslint:disable-next-line:no-import-side-effect
import "jasmine";

describe("My Unit Test", () => { /* ... */ } );

Natürlich müssen Sie noch Jasmin und die Typisierungen installieren:

$ npm i jasmine @types/jasmine --save-dev

Es sind jedoch keine speziellen Jasminlader für Knoten oder Knoten erforderlich. Führen Sie einfach Jasmin gegen die kompilierten JS-Dateien aus:

$ node ./node_modules/jasmine/bin/jasmine.js --config=test/support/jasmine.json

Angenommen, Ihre TypeScript-Dateien befinden sich innerhalb eines "test" -Unterverzeichnisses, das zu bin/test kompiliert wird, und Sie haben einen test/support/jasmine.json mit einem der folgenden Werte:

{
    "spec_dir": "bin/test",
    "spec_files": [
      "**/*[sS]pec.js"
    ],
    "stopSpecOnExpectationFailure": false,
    "random": false
}

P.S. Alle oben genannten Funktionen funktionieren auch unter Windows

1
Graeme Wicksted

Wenn Sie Probleme beim Importieren haben, verwenden Sie tsconfig-paths

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

Führen Sie TypeScript-fähigen Jasmin aus:

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

Stellen Sie sicher, dass Ihr Jasmin .ts-Dateien durchsucht:

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

Zum Testen Ihrer Skripte benötigen Sie möglicherweise auch Polyfills, wenn Sie sie in Ihrem Projekt verwenden. Erstellen Sie eine Helper-Datei mit den erforderlichen Importen wie helpers/global/polifill.ts

import 'core-js';
0

Aus irgendeinem Grund wurde das nie richtig beantwortet, natürlich haben sich die Dinge geändert, aber hier gibt es keine moderne Antwort. Ich bin hier durch Google gekommen, weil ich faul bin und manchmal Google-Snippets.

Falls Sie mit diesem Problem konfrontiert sind, stellen Sie sicher, dass Sie @typings/jasmine als devDependency installiert haben und Ihre tsConfig die Typisierungen in den Includes enthält, z.

  "include": ["typings/**/*.d.ts"]
0
Mathijs Segers