Tengo un módulo AMD que quiero probar, pero quiero burlarme de sus dependencias en lugar de cargar las dependencias reales. Estoy usando requirejs, y el código para mi módulo se parece a esto:

define(['hurp', 'durp'], function(Hurp, Durp) {
  return {
    foo: function () {
      console.log(Hurp.beans)
    },
    bar: function () {
      console.log(Durp.beans)
    }
  }
}

¿Cómo puedo burlar a cabo hurpy durppor lo que puede efectivamente prueba de unidad?

Entonces, después de leer esta publicación, se me ocurrió una solución que utiliza la función de configuración requirejs para crear un nuevo contexto para su prueba donde simplemente puede burlarse de sus dependencias:

var cnt = 0;
function createContext(stubs) {
  cnt++;
  var map = {};

  var i18n = stubs.i18n;
  stubs.i18n = {
    load: sinon.spy(function(name, req, onLoad) {
      onLoad(i18n);
    })
  };

  _.each(stubs, function(value, key) {
    var stubName = 'stub' + key + cnt;

    map[key] = stubName;

    define(stubName, function() {
      return value;
    });
  });

  return require.config({
    context: "context_" + cnt,
    map: {
      "*": map
    },
    baseUrl: 'js/cfe/app/'
  });
}

Por lo tanto, crea un nuevo contexto donde las definiciones Hurpy Durpserán establecidas por los objetos que pasó a la función. El Math.random para el nombre está quizás un poco sucio pero funciona. Porque si tiene un montón de pruebas, necesita crear un nuevo contexto para cada suite para evitar reutilizar sus simulacros, o cargar simulacros cuando desee el módulo requirejs real.

En su caso, se vería así:

(function () {

  var stubs =  {
    hurp: 'hurp',
    durp: 'durp'
  };
  var context = createContext(stubs);

  context(['yourModuleName'], function (yourModule) {

    //your normal jasmine test starts here

    describe("yourModuleName", function () {
      it('should log', function(){
         spyOn(console, 'log');
         yourModule.foo();

         expect(console.log).toHasBeenCalledWith('hurp');
      })
    });
  });
})();

Así que estoy usando este enfoque en producción por un tiempo y es realmente robusto.

es posible que desee ver la nueva biblioteca Squire.js

de los documentos:

¡Squire.js es un inyector de dependencias para que los usuarios de Require.js faciliten burlarse de las dependencias!

He encontrado tres soluciones diferentes para este problema, ninguna de ellas agradable.

Definición de dependencias en línea

define('hurp', [], function () {
  return {
    beans: 'Beans'
  };
});

define('durp', [], function () {
  return {
    beans: 'durp beans'
  };
});

require('hurpdhurp', function () {
  // test hurpdurp in here
});

Fugly Tienes que abarrotar tus pruebas con muchas repeticiones de AMD.

Carga de dependencias simuladas de diferentes rutas

Esto implica el uso de un archivo config.js separado para definir rutas para cada una de las dependencias que apuntan a simulacros en lugar de las dependencias originales. Esto también es feo, ya que requiere la creación de toneladas de archivos de prueba y archivos de configuración.

Fingirlo en el nodo

Esta es mi solución actual, pero sigue siendo terrible.

Usted crea su propia definefunción para proporcionar sus propios simulacros al módulo y poner sus pruebas en la devolución de llamada. Luego, evalel módulo para ejecutar sus pruebas, así:

var fs = require('fs')
  , hurp = {
      beans: 'BEANS'
    }
  , durp = {
      beans: 'durp beans'
    }
  , hurpDurp = fs.readFileSync('path/to/hurpDurp', 'utf8');
  ;



function define(deps, cb) {
  var TestableHurpDurp = cb(hurp, durp);
  // now run tests below on TestableHurpDurp, which is using your
  // passed-in mocks as dependencies.
}

// evaluate the AMD module, running your mocked define function and your tests.
eval(hurpDurp);

Esta es mi solución preferida. Parece un poco mágico, pero tiene algunos beneficios.

1. Ejecute sus pruebas en el nodo, para no meterse con la automatización del navegador.
2. Menos necesidad de repetitivo AMD desordenado en sus pruebas.
3. Puedes usarlo evalcon ira e imaginar a Crockford explotando de rabia.

Todavía tiene algunos inconvenientes, obviamente.

1. Como está probando en el nodo, no puede hacer nada con los eventos del navegador o la manipulación del DOM. Solo es bueno para probar la lógica.
2. Todavía un poco torpe para configurar. Debe simulacros defineen cada prueba, ya que allí es donde realmente se ejecutan sus pruebas.

Estoy trabajando en un corredor de prueba para dar una sintaxis más agradable para este tipo de cosas, pero todavía no tengo una buena solución para el problema 1.

Conclusión

Burlarse de los departamentos en requirejs es una mierda. Encontré una forma en que funciona, pero todavía no estoy muy contento con eso. Por favor, avíseme si tiene alguna idea mejor.

Hay una config.mapopción http://requirejs.org/docs/api.html#config-map .

Sobre cómo usarlo:

1. Definir módulo normal;
2. Definir módulo de código auxiliar;

3. Configure RequireJS explícitamente;

   requirejs.config({
     map: {
       'source/js': {
         'foo': 'normalModule'
       },
       'source/test': {
         'foo': 'stubModule'
       }
     }
   });

En este caso, para el código normal y de prueba, puede usar el foomódulo, que será una referencia real del módulo y el código auxiliar correspondiente.

Puede usar testr.js para burlarse de las dependencias. Puede configurar testr para cargar las dependencias simuladas en lugar de las originales. Aquí hay un ejemplo de uso:

var fakeDep = function(){
    this.getText = function(){
        return 'Fake Dependancy';
    };
};

var Module1 = testr('module1', {
    'dependancies/dependancy1':fakeDep
});

Mira esto también: http://cyberasylum.janithw.com/mocking-requirejs-dependencies-for-unit-testing/

Esta respuesta se basa en la respuesta de Andreas Köberle .
No fue tan fácil para mí implementar y comprender su solución, por lo que lo explicaré con un poco más de detalle cómo funciona, y algunas dificultades para evitar, con la esperanza de que ayude a futuros visitantes.

Entonces, primero que nada la configuración:
estoy usando Karma como corredor de prueba y MochaJs como marco de prueba.

Usar algo como Squire no funcionó para mí, por alguna razón, cuando lo usé, el marco de prueba arrojó errores:

TypeError: no se puede leer la propiedad 'call' de undefined

RequireJs tiene la posibilidad de asignar identificadores de módulo a otros identificadores de módulo. También permite crear una requirefunción que utiliza una configuración diferente a la global require.
Estas características son cruciales para que esta solución funcione.

Aquí está mi versión del código simulado, que incluye (muchos) comentarios (espero que sea comprensible). Lo envolví dentro de un módulo, para que las pruebas puedan requerirlo fácilmente.

define([], function () {
    var count = 0;
    var requireJsMock= Object.create(null);
    requireJsMock.createMockRequire = function (mocks) {
        //mocks is an object with the module ids/paths as keys, and the module as value
        count++;
        var map = {};

        //register the mocks with unique names, and create a mapping from the mocked module id to the mock module id
        //this will cause RequireJs to load the mock module instead of the real one
        for (property in mocks) {
            if (mocks.hasOwnProperty(property)) {
                var moduleId = property;  //the object property is the module id
                var module = mocks[property];   //the value is the mock
                var stubId = 'stub' + moduleId + count;   //create a unique name to register the module

                map[moduleId] = stubId;   //add to the mapping

                //register the mock with the unique id, so that RequireJs can actually call it
                define(stubId, function () {
                    return module;
                });
            }
        }

        var defaultContext = requirejs.s.contexts._.config;
        var requireMockContext = { baseUrl: defaultContext.baseUrl };   //use the baseUrl of the global RequireJs config, so that it doesn't have to be repeated here
        requireMockContext.context = "context_" + count;    //use a unique context name, so that the configs dont overlap
        //use the mapping for all modules
        requireMockContext.map = {
            "*": map
        };
        return require.config(requireMockContext);  //create a require function that uses the new config
    };

    return requireJsMock;
});

El mayor obstáculo que encontré, que literalmente me costó horas, fue crear la configuración RequireJs. Traté de copiarlo (en profundidad) y solo anular las propiedades necesarias (como contexto o mapa). ¡Esto no funciona! Solo copie el baseUrl, esto funciona bien.

Uso

Para usarlo, solicítelo en su prueba, cree los simulacros y luego páselo createMockRequire. Por ejemplo:

var ModuleMock = function () {
    this.method = function () {
        methodCalled += 1;
    };
};
var mocks = {
    "ModuleIdOrPath": ModuleMock
}
var requireMocks = mocker.createMockRequire(mocks);

Y aquí un ejemplo de un archivo de prueba completo :

define(["chai", "requireJsMock"], function (chai, requireJsMock) {
    var expect = chai.expect;

    describe("Module", function () {
        describe("Method", function () {
            it("should work", function () {
                return new Promise(function (resolve, reject) {
                    var handler = { handle: function () { } };

                    var called = 0;
                    var moduleBMock = function () {
                        this.method = function () {
                            methodCalled += 1;
                        };
                    };
                    var mocks = {
                        "ModuleBIdOrPath": moduleBMock
                    }
                    var requireMocks = requireJsMock.createMockRequire(mocks);

                    requireMocks(["js/ModuleA"], function (moduleA) {
                        try {
                            moduleA.method();   //moduleA should call method of moduleBMock
                            expect(called).to.equal(1);
                            resolve();
                        } catch (e) {
                            reject(e);
                        }
                    });
                });
            });
        });
    });
});

si desea hacer algunas pruebas js simples que aíslan una unidad, simplemente puede usar este fragmento:

function define(args, func){
    if(!args.length){
        throw new Error("please stick to the require.js api which wants a: define(['mydependency'], function(){})");
    }

    var fileName = document.scripts[document.scripts.length-1].src;

    // get rid of the url and path elements
    fileName = fileName.split("/");
    fileName = fileName[fileName.length-1];

    // get rid of the file ending
    fileName = fileName.split(".");
    fileName = fileName[0];

    window[fileName] = func;
    return func;
}
window.define = define;