La fonction Stub n'est pas appelée, mais la version réelle est appelée. Pourquoi?

Question

J'essaie de tester une fonction qui appelle deux autres fonctions qui se connectent à Amazon AWS. En gardant cela à l'esprit, je ne veux pas appeler les vraies fonctions qui appellent AWS - j'essaie de les écraser. Cependant, chaque fois que j'exécute mon test, j'appelle les vraies fonctions et non mes talons.

Je suis un peu nouveau pour tester et pourrait manquer quelque chose, mais je n'ai pas trouvé de solution pour toute autre question. J'utilise jasmine et sinon

Mon code est le suivant:

const cache = new Map<string, Set<string>>(); 
//Function to be tested - inside class XYZ 
export function functionToBeTest(events: Event[]): Promise<Event[]> { 
    cache.clear(); 
    let promises: Array<Promise<void>> = []; 
    promises = events.map((event) => { 
     let foundId: string; 
     return functionA(event.Id) 
      .then((id: string) => { 
       foundId = id; 
       if (!cache.has(id)) { 
        return functionB(id); 
       } 
      }) 
      .then((regDev) => { 
       cache.set(foundId, new Set(regDev)); 
      }) 
      .catch((err) => { 
       log.error({ err: err }); 
       return Promise.reject(err); 
      }); 
    }); 

    return Promise.all(promises) 
     .then(() => { 
      return Promise.resolve(events) 
     }); 
} 

Les fonctions que je veux stub:

export function functionA(id: string): Promise<string> {//Return Promise<string> 
//some code 
return anotherFunction(id); 
} 

export function functionB(organizationId: string): Promise<string[]> { 
//Goes to amazon do something and return Promise<string[]> 
} 

J'omis la mise en œuvre de functionA et functionB depuis que je don Ne vous souciez pas de ce qu'ils font ou de la façon dont j'ai juste besoin de les boucher afin que je teste la logique à l'intérieur functionToBeTest.

Ma suite de test est la suivante:

import * as sinon from 'sinon'; 

describe('testing functionToBeTest()',() => { 

    let stubA: sinon.SinonStub; 
    let stubB: sinon.SinonStub; 

    beforeEach(() => { 
     stubA = sinon.stub(xyz, 'functionA'); 
     stubA.onFirstCall().resolves('1'); 
     stubA.onSecondCall().resolves('2'); 
     stubB = sinon.stub(xyz, 'functionB'); 
     stubB.onFirstCall().resolves(['1']); 
     stubB.onSecondCall().resolves(['2']); 
    }); 

    afterEach(() => { 
     stubA.restore(); 
     stubB.restore(); 
    }); 

    it('should populate the cache', (done) => { 
     let events: Event[] = [ 
      { 
       timestamp: 1, 
       eventType: EventType.PC, 
       id: '1' 
      }, 
      { 
       timestamp: 2, 
       eventType: EventType.BU, 
       id: '2' 
      } 
     ]; 
     xyz.functionToBeTest(events)// Here should call the real function and inside it should call the stub functions 
     .then((result) => { 
      //expectations 
     }) 
     .then(() => { 
      done(); 
     }) 
     .catch((err) => { 
      done.fail(err); 
     }); 
    }); 
}); 

Comme je l'ai dit, quand je lance ce test, il ne jamais appeler les fonctions stub et me renvoient toujours des erreurs à l'intérieur des fonctions réelles (qui devrait être écrasa).

Quelqu'un peut-il vous aider? Je peux me tromper, mais je ne vois pas ce qui ne va pas.

Answer 1

Imaginé que c'était une référence problématique. Au lieu d'appeler le talon de la méthode, il appelait le vrai. Pour résoudre ce problème, j'ai dû changer ma classe d'origine en l'exportant et en utilisant public static sur les méthodes que je veux utiliser à l'extérieur.