¿Alguna forma de modificar los espías de Jasmine en función de los argumentos?

Tengo una función que me gustaría probar que llama a un método API externo dos veces, usando diferentes parámetros. Me gustaría burlarme de esta API externa con un espía Jasmine, y devolver diferentes cosas según los parámetros. ¿Hay alguna manera de hacer esto en Jasmine? Lo mejor que puedo encontrar es un hack usando andCallFake:

var functionToTest = function() {
  var userName = externalApi.get('abc');
  var userId = externalApi.get('123');
};


describe('my fn', function() {
  it('gets user name and ID', function() {
    spyOn(externalApi, 'get').andCallFake(function(myParam) {
      if (myParam == 'abc') {
        return 'Jane';
      } else if (myParam == '123') {
        return 98765;
      }
    });
  });
});

En Jasmine versiones 3.0 y superiores puedes usar withArgs

describe('my fn', function() {
  it('gets user name and ID', function() {
    spyOn(externalApi, 'get')
      .withArgs('abc').and.returnValue('Jane')
      .withArgs('123').and.returnValue(98765);
  });
});

Para las versiones de Jasmine anteriores a la 3.0 callFakees el camino correcto, pero puede simplificarlo usando un objeto para contener los valores de retorno

describe('my fn', function() {
  var params = {
    'abc': 'Jane', 
    '123': 98765
  }

  it('gets user name and ID', function() {
    spyOn(externalApi, 'get').and.callFake(function(myParam) {
     return params[myParam]
    });
  });
});

Dependiendo de la versión de Jasmine, la sintaxis es ligeramente diferente:

• 1.3.1: .andCallFake(fn)
• 2.0: .and.callFake(fn)

Recursos:

• con documentos de Args
• documentos callFake
• andCallFake vs and.callFake

También puedes usar $providepara crear un espía. Y simula usar usando en and.returnValueslugar de and.returnValuepasar datos parametrizados.

Según los documentos de Jasmine: al encadenar al espía and.returnValues, todas las llamadas a la función devolverán valores específicos en orden hasta que llegue al final de la lista de valores de retorno, momento en el que volverá indefinido para todas las llamadas posteriores.

describe('my fn', () => {
    beforeEach(module($provide => {
        $provide.value('externalApi', jasmine.createSpyObj('externalApi', ['get']));
    }));

        it('get userName and Id', inject((externalApi) => {
            // Given
            externalApi.get.and.returnValues('abc','123');

            // When
            //insert your condition

            // Then
            // insert the expectation                
        }));
});

En mi caso, tenía un componente que estaba probando y, en su constructor, hay un servicio de configuración con un método llamado getAppConfigValue que se llama dos veces, cada vez con diferentes argumentos:

constructor(private configSvc: ConfigService) {
  this.configSvc.getAppConfigValue('a_string');
  this.configSvc.getAppConfigValue('another_string');
}

En mi especificación, proporcioné el ConfigService en TestBed de la siguiente manera:

{
  provide: ConfigService,
  useValue: {
    getAppConfigValue: (key: any): any {
      if (key === 'a_string) {
        return 'a_value';
      } else if (key === 'another_string') {
        return 'another_value';
      }
    }
  } as ConfigService
}

Por lo tanto, siempre que la firma de getAppConfigValue sea ​​la misma que la especificada en el ConfigService real, lo que hace la función internamente puede modificarse.