AngularJS - Come verificare se una funzione viene chiamata da un'altra funzione?

Question

Sto cercando di iniziare con il karma-gelsomino e mi chiedo perché questo test non riesce:

it("should call fakeFunction", function() { 
    spyOn(controller, 'addNew'); 
    spyOn(controller, 'fakeFunction'); 
    controller.addNew(); 
    expect(controller.fakeFunction).toHaveBeenCalled(); 
}); 

Nel mio controller che ho in precedenza ha installato per questo test ho il seguente:

function addNew() { 
    fakeFunction(3); 
} 

function fakeFunction(number) { 
    return number; 
} 

sia addNew e fakeFunction sono esposte utilizzando:

vm.addNew = addNew; 
vm.fakeFunction = fakeFunction; 

il test, però, non riesce con il seguente:

Expected spy fakeFunction to have been called.

posso far passare il test se chiamo la funzione da dentro il mio test. Speravo, tuttavia, di poter verificare se fakeFunction era stato chiamato da un'altra funzione. Qual è il modo corretto per raggiungere questo obiettivo?

Aggiornamento:

//test.js 

beforeEach(function() { 

    module("app"); 

    inject(function(_$rootScope_, $controller) { 

     $scope = _$rootScope_.$new(); 
     controller = $controller("CreateInvoiceController", {$scope: $scope}); 

    }); 

}); 

Se testare qualcosa di simile:

it('should say hello', function() { 
    expect(controller.message).toBe('Hello'); 
}); 

Il test viene superato se metto il seguente nel mio controller:

var vm = this; 
vm.message = 'Hello'; 

Voglio solo sapere come posso verificare se una funzione pubblica è stata chiamata da un'altra funzione.

Answer 1

Il tuo metodo addNew sta chiamando fakeFunction. Tuttavia, non sta chiamando controller.fakeFunction, che è la vostra aspettativa.

È necessario modificare il codice per utilizzare il controller, anziché queste funzioni indipendenti.

MODIFICA: È inoltre necessario non spiare la funzione addNew. Questo sta causando la sostituzione della funzione con una spia. L'altra alternativa è quella di cambiarlo in:

spyOn(controller, 'addNew').and.callThrough() 

Answer 2

Mi sono imbattuto in questo problema. La precedente risposta di @Vadim ha i giusti principi ma non penso che tutto sia stato chiarissimo. Nel mio caso, sto provando a chiamare una funzione pubblica su un servizio da un'altra funzione. Qui ci sono i frammenti rilevanti:

Servizio:

angular.module('myApp').factory('myService', function() { 
 

 
    function doSomething() { 
 
     service.publicMethod(); 
 
    } 
 

 
    function publicMethod(){ 
 
     // Do stuff 
 
    } 
 

 
    var service = { 
 
     publicMethod: publicMethod 
 
    }; 
 

 
    return service; 
 
});

prova:

it('calls the public method when doing something', function(){ 
 
    spyOn(service, 'publicMethod'); 
 

 
    // Run stuff to trigger doSomething() 
 

 
    expect(service.publicMethod).toHaveBeenCalled(); 
 
});

La chiave qui è che il functio n essere testato deve chiamare lo stesso riferimento della funzione pubblica che viene spiata.