Prueba de ronco para UMD

Estoy tratando de descubrir el mejor enfoque para probar una definición de module de Javascript usando una fábrica de UMD, similar a esto: https://github.com/umdjs/umd/blob/master/returnExportsGlobal.js

No quiero probar el module en sí, quiero probar que el module se 'exporta / crea' correctamente en los diversos entornos:

  1. Si CommonJS (nodo), ¿el module se exporta correctamente?
  2. Si AMD, ¿está definido correctamente?
  3. Si el browser (sin requirejs), ¿se ha creado correctamente el global?

Me gustaría ejecutar estas testings usando ronco y jasmine. Puedo usar grunt-contrib-jasmine para probar los puntos 2 y 3, pero no para el punto 1.

Supongo que puedo usar un brebaje de gruad-contrib-jasmine y gruñido-jasmine-nodo para probar las definiciones correctas de los modules (implementación específica que todavía tengo que resolver), pero se siente muy desorderado.

En un nivel alto, ¿alguien sabe de algún método existente para lograr esto sin usar múltiples plugins de grunt?

Al final, decidí ir con las tareas híbridas, usando grunt-contrib-jasmine para las testings AMD de browser global y de browser, y jasmine_node para las testings CommonJS. Solo tengo un file de especificación que admite las 3 testings de tipo de module.

Aquí está mi configuration de grunt:

grunt.initConfig({ pkg: grunt.file.readJSON('package.json'), jasmine: { browserGlobal: { src: ['src/Foo.js'], options: { specs: 'spec/**/*.spec.js' } }, browserAMD: { src: ['src/Foo.js'], options: { specs: 'spec/**/*.spec.js', template: require('grunt-template-jasmine-requirejs') } } }, jasmine_node: { specNameMatcher: 'spec', projectRoot: 'spec/' } }); 

Mis files de especificaciones jasmine ahora son compatibles con UMD:

 (function (root, factory) { if (typeof module === 'object' && module.exports) { // Node/CommonJS factory( require('modulename') ); } else if (typeof define === 'function' && define.amd) { // AMD define([ 'modulename' ], factory); } else { // Browser globals factory(root.ModuleName); } }(this, function factory(ModuleName) { // Tests here })); 

Y aquí está la fábrica de UMD que estoy usando para mi module:

 (function (root, factory) { if (typeof module === 'object' && module.exports) { // Node/CommonJS module.exports = factory(); } else if (typeof define === 'function' && define.amd) { // AMD. Register as an anonymous module. define(factory); } else { // Browser globals root.ModuleName = factory(); } }(this, function factory() { // public API return { foo: 'bar' }; })); 

También puede usar uRequire y savese a sí mismo de todos los estándares de UMD en todos sus modules, mientras usa características declarativas .

Simplemente escriba AMD simple o modules comunes de CommonJS (o una combinación de dos) y conviértalos a UMD (o un rjs optimizado combined.js que se ejecuta como está en nodejs , Web / AMD y Web / Script ) con un simple paso de compilation y config , ya sea en CLI o en gruñido .

El UMD producido se basa en templates bien conocidas como https://github.com/umdjs/umd/blob/master/returnExportsGlobal.js , con varios ajustes, uno de ellos es que puede exportar de forma declarativa a la window / global .

A continuación, puede convertir las especificaciones simples de AMD o de commonJS a UMD y / o 'combined.js' y presionar ambas en un browser o grunt-mocha. Vea uBerscore para muchos ejemplos triviales y más avanzados.