Les tests unitaires à l'aide de Jasmin et de Tapuscrit

Je suis en train d'essayer d'obtenir une unité de test écrit en caractères d'imprimerie à l'aide de Jasmin pour compiler. Avec la suite de mon unité-fichier de test, Resharper me demande avec un lien pour importer les types de jasmin.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");
    });
});

Donc je clique sur le lien et finissent avec les éléments suivants (en fait resharper seulement préfixé l'décrire la fonction avec "Jasmine.", j'ai donc manuellement préfixé l'autre Jasmin appels):

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

Cependant l'instruction d'importation a une rouge, ligne sinueuse, avec message d'erreur "Impossible de résoudre un module externe ../../../scripts/typings/jasmin/jasmin. Le Module ne peut être un alias pour un non-module de type"

Aucune idée de ce qui est à l'origine de cette erreur? J'ai vérifié que le Module "Système" est définie à AMD dans mon projet de paramètres de construction. J'ai également vérifié que le jasmin module est défini dans le jasmin.d.ts. J'ai téléchargé ce fichier à partir de DefinitelyTyped site.

declare module jasmine {
    ...
}

es6: import Jasmine from 'path/here';. es5: var Jasmine = require('path/here');. Utilisation beforeEach, it et expect au lieu de BeforeEach, It et Expect.
Merci pour votre réponse. J'ai pensé à la Machine ce qui suit est valable? l'importation de Jasmin = require("..."). Mais peut-être pas que c'est en donnant de nombreuses erreurs de compilation...

InformationsquelleAutor aw1975 | 2015-06-16

41

Voici (à mon avis) le meilleur moyen de tester un ts-node application à partir de 2018:
```
npm install --save-dev jasmine @types/jasmine ts-node
```
Dans package.json:
```
{
  "scripts": {
    "test": "ts-node node_modules/jasmine/bin/jasmine"
  }
}
```
Dans vos fichiers de spec:
```
import "jasmine";
import something from "../src/something";

describe("something", () => {
    it("should work", () => {
        expect(something.works()).toBe(true);
    });
});
```
Pour exécuter les tests:
```
npm test
```
Cela utiliser localement les versions installées de ts-node et jasmine. C'est mieux que d'utiliser l'échelle mondiale versions installées, parce qu'avec les versions locales, vous pouvez être sûr que tout le monde utilise la même version.

Remarque: si vous avez une application web au lieu d'un nœud de l'application, vous devriez probablement de l'exécution des tests à l'aide de Karma au lieu de le Jasmin de la CLI.
- Quand j'ai essayer cela je reçois le même problème que lorsque je suis de tout autre tutoriel sur la façon de le faire: "ReferenceError: définir n'est pas défini". Je pense que c'est soit parce que je suis en utilisant webpack ou le fait que c'est un vss web du kit de développement de l'extension.
- Cette méthode est destinée à la plaine ts-tests de nœud (sans webpack). Si vous voulez webpack, vous devriez probablement utiliser le karma.
- Dans le cas où vous avez besoin de fournir des arguments à jasmine: "test": "ts-node --project ./tsconfig-server.json node_modules/jasmine/bin/jasmine --config=jasmine.json",
InformationsquelleAutor AJ Richardson
7

Mettre en haut de votre fichier d'enregistrement dans le fichier de spécification:
```
///<reference path="../../node_modules/@types/jasmine/index.d.ts" />
let Jasmine = require('jasmine');
```
Vous devez installer la suite de Jasmin modules pour que cela fonctionne:
```
$ npm install jasmine-core jasmine @types/jasmine jasmine-ts --save-dev
```
Une fois que vous faites cela, l'IDE (comme WebStorm) reconnaîtra Jasmin et de ses fonctions, telles que les décrivent(), ce(), et attendre().. Si vous n'avez pas besoin de les préfixer avec le "Jasmin." Aussi, vous pouvez exécuter vos spécifications des fichiers à partir de la ligne de commande en utilisant le jasmin-module. L'installation de ces outils de ligne de commande à l'échelle mondiale:
```
$ npm install -g jasmine jasmine-ts
```
Ensuite configurer le "jasmin" en ligne de commande module de sorte que le Jasmin peut trouver son fichier de configuration. Ensuite, vous devriez être en mesure d'exécuter le jasmin-ts et de votre fichier spec devrait fonctionner correctement à partir de la ligne de commande:
```
./node_modules/.bin/jasmine-ts src/something.spec.ts
```
.. et, vous pouvez configurer votre IDE pour l'exécuter comme ça, et debug fonctionne de cette façon, il devrait également travailler (pour moi).

Écrire vos tests de cette façon, vous pouvez exécuter une Jasmin test spec sur le côté serveur sans Karma, ou de l'exécuter dans un navigateur web en utilisant le Karma. Même tapuscrit code.
- Le problème avec jasmine-ts est qu'il est basé sur le Jasmin 2, de sorte que vous ne pouvez pas utiliser la dernière et la plus grande de Jasmin 3 caractéristiques. J'espère qu'ils vont faire un tri. Il y a un ticket sur GitHub: github.com/svi3c/jasmine-ts/issues/27
- nous, puisque c'est la communauté open source. Donc n'importe qui peut l'améliorer, et je vous encourage, parce que oui, ce serait certainement être utile pour l'amélioration de la!
InformationsquelleAutor Yavin5
5

Pour moi, je n'ai suivantes:

Installer Typings
```
npm install typings --global
```
Puis ajouter le typings pour jasmine
```
typings install dt~jasmine --save --global
```
- Vous ne devriez vraiment pas être à l'aide de typings plus. Beaucoup mieux d'utiliser les définitions de types dans le @types/* repos dans MNP.
InformationsquelleAutor Andrew Newland

Inclure à votre jasmin fichier html,...

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

...ou installer le mécanisme national de prévention de jasmin package:

npm install --save-dev jasmine

lorsque vous utilisez le deuxième moyen (jasmin module de), vous devez l'importer:

var jasmine = require('jasmine');

import jasmine from 'jasmine';

puis de modifier le code des autres:

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

Personnellement, je préfère la première façon de le faire sans l'aide de l'jasmin mnp module. (Je n'ai pas tester le module encore)

InformationsquelleAutor marcel

1

Si vous avez des problèmes avec l'importation, l'utilisation tsconfig-paths
```
npm i ts-node tsconfig-paths types/jasmine jasmine --save-dev
```
Exécuter tapuscrit-permis jasmin:
```
ts-node -r tsconfig-paths/register node_modules/jasmine/bin/jasmine.js
```
De s'assurer que votre jasmin recherche .les fichiers ts:
```
"spec_files": [
    "**/*[sS]pec.ts"
],
"helpers": [
    "helpers/**/*.ts"
],
```
Pour tester vos scripts, vous pouvez aussi avoir besoin polyfills si vous les utilisez dans votre projet. Créer un helper fichier nécessaire avec les importations, à l'instar de helpers/global/polifill.ts
```
import 'core-js';
```
InformationsquelleAutor Sergey P. aka azure
1

Vous pouvez essayer un effet secondaire uniquement importer des qui apporte dans le @types/jasmine de déclaration et de lieux de jasmin fonctions dans la portée globale de sorte que vous n'avez pas besoin de préfixe de chaque appel avec jasmine. permettant un port rapide existantes sur les tests unitaires et joue encore gentil avec webpack.
```
//tslint:disable-next-line:no-import-side-effect
import "jasmine";

describe("My Unit Test", () => { /* ... */ } );
```
Bien sûr, vous devez installer le jasmin et la typings:
```
$ npm i jasmine @types/jasmine --save-dev
```
Mais pas besoin spécialisés jasmin chargeurs pour ts ou un nœud. Il suffit d'exécuter le jasmin à l'encontre de la compilation des fichiers js:
```
$ node ./node_modules/jasmine/bin/jasmine.js --config=test/support/jasmine.json
```
En supposant que votre tapuscrit les fichiers sont dans un "test" sous-répertoire de compilation pour bin/test et vous avez un test/support/jasmine.json avec quelque chose comme ceci:
```
{
    "spec_dir": "bin/test",
    "spec_files": [
      "**/*[sS]pec.js"
    ],
    "stopSpecOnExpectationFailure": false,
    "random": false
}
```
P. S. tous les ci-dessus fonctionne sur Windows trop

InformationsquelleAutor Graeme Wicksted
0

Pour une raison quelconque, cela n'a jamais été correctement répondu, bien sûr, les choses ont changé, mais pas de réponse moderne existe ici, je suis venu ici grâce à google parce que je suis paresseux et je google des extraits parfois.

Dans le cas où vous faites face à ce problème, assurez-vous que vous avez @typings/jasmine installé comme devDependency et votre tsConfig contient les typings dans l'inclut par exemple,
```
  "include": ["typings/**/*.d.ts"]
```
- N'est-ce pas, c'est @types/jasmine?
- Bonne astuce mais @SimonWarta est droit, vous devez installer les types avec npm install @types/jasmine. Il n'est pas include dans la version actuelle (2.7.2) de Tapuscrit de configuration, la nouvelle configuration devrait être comme ça. "typeRoots": ["./node_modules/@types"],
- Dans ma situation, j'ai eu ces typings installés, mais il n'était pas assez. Et je l'ai fait essayer votre suggestion.
InformationsquelleAutor Mathijs Segers

Vous devez vous connecter pour publier un commentaire.