TypeScript SinonStub.onCall方法代码示例

    beforeEach(() => {
      destroyStub            = sandbox.stub();
      blocksModule.lastBlock = {
        height       : 10,
        previousBlock: 'previousBlock',
        transactions : [
          { senderPublicKey: 'first' },
          { senderPublicKey: 'second' },
          { senderPublicKey: 'third' },
        ],
        destroy      : destroyStub,
      } as any;
      roundsModule.enqueueResponse('backwardTick', Promise.resolve());
      txLogic.stubs.undoUnconfirmed.resolves([]);
      txLogic.stubs.undo.resolves([]);
      dbStub.stubs.performOps.resolves();
      // accountsModule.stubs.getAccount.callsFake((a) => a);
      accountsModule.stubs.resolveAccountsForTransactions.callsFake((txs)=> {
        const toRet = {};
        txs.forEach((tx) => toRet[tx.senderId] = tx.senderId);
        return toRet;
      });
      sandbox.stub(blocksModel.sequelize, 'transaction').callsFake((cb) => {
        return cb('tx');
      });
      findStub = sandbox.stub(blocksModel, 'findById');
      findStub.onCall(0).resolves(blocksModule.lastBlock);
      findStub.onCall(1).resolves({toJSON() { return { id: 'previousBlock' }}});

      const accountsModel = container.get<any>(Symbols.models.accounts);
      accountsFindStub    = sandbox.stub().returns('senderAccount');
      accountsScopeStub   = sandbox.stub(accountsModel, 'scope').returns({
        find: accountsFindStub
      });
    });

      it('should not throw error if only address === query.address and check of setting address in query.address if query.publicKey is empty', async () => {
        isEmptyStub.onCall(1).returns(true);
        isEmptyStub.onCall(2).returns(false);
        isEmptyStub.onCall(3).returns(false);

        await expect(instance.getAccount(query)).to.be.not.rejectedWith('Account publicKey does not match address');
      });

    it('is set to false after a series of retry that fail that succeed', function(done) {
      const firstResponse = new Response(null, { status: 500 });
      const secondResponse = new Response(null, { status: 200 });

      fetch.onCall(0).returns(Promise.resolve(firstResponse));
      fetch.onCall(1).returns(Promise.resolve(secondResponse));

      client.configure(config => config.rejectErrorResponses().withRetry({
        maxRetries: 3,
        interval: 1,
        strategy: retryStrategy.fixed
      }));

      expect(client.isRequesting, 'Before start').to.equal(false);
      const request = client.fetch('path');
      expect(client.isRequesting, 'When started').to.equal(true);
      request.then(() => {
        // 1 original call plus 1 retry
        expect(fetch).to.have.callCount(2);
        expect(client.isRequesting, 'When finished').to.equal(false);
        done();
      }).catch((result) => {
        done('fetch did error');
      });
    });

 beforeEach(() => {
   updateMissedBlocks = sandbox.stub(instance, 'updateMissedBlocks').returns({updateMissed: true});
   applyRound         = sandbox.stub(instance, 'applyRound').returns([{apply: 1}, {apply: 2}]);
   restoreVotesSnapshot = sandbox.stub(instance, 'restoreVotesSnapshot').returns({restorevotes: true});
   reCalcVotes        = sandbox.stub(instance, 'reCalcVotes');
   reCalcVotes.onCall(0).returns({reCalcVotes: 1});
   reCalcVotes.onCall(1).returns({reCalcVotes: 2});
 })

    beforeEach(() => {
      generatedAddress = 'generatedAddress';
      query            = {
        address  : 'address',
        publicKey: 'publicKey',
      };
      accData          = {
        _timestampAttributes: {},
        address             : 'address',
        balance             : 'balance',
        multisignatures     : [],
        publicKey           : Buffer.from('0011aabbccddeeff0011aabbccddeeff0011aabbccddeeff0011aabbccddeeff', 'hex'),
        secondPublicKey     : Buffer.from('1111aabbccddeeff0011aabbccddeeff0011aabbccddeeff0011aabbccddeeff', 'hex'),
        secondSignature     : 1,
        u_balance           : '10000',
        u_multisignatures   : [],
        u_secondSignature   : 1,
      };

      accountsModule.enqueueResponse('generateAddressByPublicKey', generatedAddress);
      accountsModule.enqueueResponse('getAccount', Promise.resolve(new AccountsModel(accData)));

      isEmptyStub = sandbox.stub();
      isEmptyStub.onCall(0).returns(false)
        .onCall(1).returns(false)
        .onCall(2).returns(true)
        .onCall(3).returns(true);
    });

 it('should throw error if previousblock is null', async () => {
   blocksUtils.reset();
   findStub.onCall(0).resolves(null);
   await expect(inst.deleteLastBlock()).to.be.rejectedWith('previousBlock is null');
   expect(findStub.called).is.true;
 });