javascript - example - Pruebas unitarias utilizando Jasmine y TypeScript.

pruebas unitarias angular js

Question

Estoy tratando de obtener una prueba de unidad escrita en Typescript usando Jasmine para compilar. Con lo siguiente en mi archivo de prueba de unidad, Resharper me solicita un enlace para importar tipos de 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");
    });
});

Así que hago clic en el enlace y termino con lo siguiente (en realidad, el resharper solo tenía el prefijo de la función de descripción con "Jasmine", por lo que prefijé manualmente las otras llamadas de 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");
    });
});

Sin embargo, la declaración de importación tiene una línea ondulada roja con el mensaje de error "No se puede resolver el módulo externo ../../../scripts/typings/jasmine/jasmine. El módulo no puede tener un alias para un tipo que no sea de módulo"

¿Alguna idea de qué está causando este error? He comprobado que la opción "Sistema de módulo" está configurada en AMD en la configuración de compilación de mi proyecto. También he comprobado que el módulo jasmine está definido en jasmine.d.ts. Descargué este archivo del sitio DefinitelyTyped.

declare module jasmine {
    ...
}

Answer 1

Esta es (en mi opinión) la mejor manera de probar una aplicación ts-node partir de 2018:

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

En package.json :

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

En sus archivos de especificaciones:

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

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

Para ejecutar las pruebas:

npm test

Esto utilizará las versiones instaladas localmente de ts-node y jasmine . Esto es mejor que usar versiones instaladas globalmente, porque con las versiones locales, puede estar seguro de que todos están usando la misma versión.

Nota: si tiene una aplicación web en lugar de una aplicación de nodo, probablemente debería ejecutar sus pruebas utilizando Karma en lugar de la CLI de Jasmine.

Answer 2

Incluya esto en su archivo html jasmine, ...

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

... o instale el paquete npm jasmine:

npm install --save-dev jasmine

cuando estés usando la segunda forma (jazmín como módulo) debes importarlo:

var jasmine = require(''jasmine'');

o

import jasmine from ''jasmine'';

luego cambia el otro código:

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 preferiría la primera manera sin usar el módulo jasmine npm. (Todavía no probé el módulo)

Answer 3

Para mi hice lo siguiente:

Instalar tipografías

npm install typings --global

A continuación, agregue los typings en jazmín

typings install dt~jasmine --save --global

Answer 4

Podría probar una importación de efectos secundarios que traiga la declaración @types/jasmine y coloque las funciones de jasmine en el ámbito global, de modo que no necesite el prefijo de cada llamada con jasmine. permitiendo un puerto rápido de las pruebas de unidades existentes y aún así funciona bien con el paquete web.

// tslint:disable-next-line:no-import-side-effect import "jasmine"; describe("My Unit Test", () => { /* ... */ } );

Por supuesto, todavía necesitas instalar jasmine y las tipificaciones:

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

Pero no hay necesidad de cargadores de jazmín especializados para ts o nodo. Simplemente ejecute jasmine contra los archivos js compilados:

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

Suponiendo que sus archivos mecanografiados están dentro de un subdirectorio de "prueba" compilando a bin/test y tiene un test/support/jasmine.json con algo como esto:

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

PS todo lo anterior funciona en Windows también

Answer 5

Ponga esto en la parte superior de su archivo de especificación mecanografiado:

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

Debe instalar los siguientes módulos Jasmine para que funcione:

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

Una vez que hagas eso, el IDE (como WebStorm) reconocerá a Jasmine y sus funciones como describir (), it (), y expect (). Por lo tanto, no es necesario que aparezcan los prefijos con "Jasmine". Además, puede ejecutar sus archivos de especificaciones desde la línea de comandos utilizando el módulo jasmine-ts. Instale estas herramientas de línea de comandos globalmente:

$ npm install -g jasmine jasmine-ts

Luego configure el módulo de línea de comandos "jasmine" para que Jasmine pueda encontrar su archivo de configuración. Entonces deberías poder ejecutar jasmine-ts y tu archivo de especificaciones debería ejecutarse bien desde la línea de comando:

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

.. y, puede configurar su IDE para ejecutarlo así, y la ejecución de la depuración también debería funcionar (funciona para mí).

Al escribir sus pruebas de esta manera, puede ejecutar una especificación de prueba Jasmine en el lado del servidor sin Karma, o ejecutarla en un navegador web usando Karma. El mismo código mecanografiado.

Answer 6

Por alguna razón, esto nunca se ha respondido correctamente, por supuesto, las cosas cambiaron pero no existe una respuesta moderna aquí, vine aquí a través de Google porque soy perezoso y a veces hago fragmentos de Google.

En el caso de que tenga este problema, asegúrese de tener @typings/jasmine instalado como devDependency y su tsConfig contiene los typings en el include, por ejemplo:

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

Answer 7

Si tiene problemas con las importaciones, use tsconfig-paths

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

Ejecutar jasmine habilitado para mecanografiar:

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

Asegúrate de que tu jasmine buscará archivos .ts:

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

Para probar sus scripts, también puede necesitar polyfills si los usa en su proyecto. Cree un archivo auxiliar con las importaciones necesarias, como helpers/global/polifill.ts

import ''core-js'';