TypeScript SinonStub.reset方法代码示例

	public constructor(public readonly settingName: string | null,
											public readonly settingValue: string | null) {
		setting.name = this.settingName;
		setting.value = this.settingValue;
		saveStub.reset();
		removeStub.reset();
	}

 it('should call getSnapshotRounds once or twice', async () => {
   getSnapshotRoundsStub.returns(0);
   await doCall();
   expect(getSnapshotRoundsStub.calledOnce).to.be.true;
   getSnapshotRoundsStub.reset();
   getSnapshotRoundsStub.returns(12);
   dbHelpersStub.enqueueResponse('performOps', Promise.resolve());
   await doCall();
   expect(getSnapshotRoundsStub.calledTwice).to.be.true;
 });

const testPkg = { 'testKey': 'testValue' };
const testInterval = 100;

registerSuite({
	name: 'updateNotifier',
	'setup'() {
		mockery.enable({
			warnOnUnregistered: false
		});

		mockery.registerMock('update-notifier', updateNotifierStub);

		updateNotifier = require('intern/dojo/node!./../../src/updateNotifier').default;
	},
	'beforeEach'() {
		notifyStub.reset();
		updateNotifierStub.reset();
	},
	'teardown'() {
		mockery.deregisterAll();
		mockery.disable();
	},
	'Should call update-notifier with the passed arguments'() {
		updateNotifier(testPkg, testInterval);
		assert.isTrue(updateNotifierStub.calledOnce);
		assert.isTrue(updateNotifierStub.firstCall.calledWith({
			'pkg': testPkg,
			'updateCheckInterval': testInterval
		}));
	},
	'Should default interval to zero if none passed'() {

		);

		loadTasks({
			fs: fs,
			execa: {
				shell: shell
			}
		});
	},
	teardown() {
		symlink.restore();
		unloadTasks();
	},

	beforeEach() {
		symlink.reset();
		shell.reset();
	},

	_link() {
		runGruntTask('_link');

		assert.isTrue(symlink.calledTwice);
		assert.isTrue(symlink.firstCall.calledWith(path.join(cwd, 'node_modules'), path.join(outputPath, 'node_modules'), 'junction'));
		assert.isTrue(symlink.secondCall.calledWith(path.join(cwd, 'package.json'), path.join(outputPath, 'package.json'), 'file'));
		assert.isTrue(shell.calledOnce);
		assert.isTrue(shell.calledWith('npm link', { cwd: outputPath }));
	},

	link: {
		beforeEach() {

	{
		groupName: 'group2',
		commands: [{ commandName: 'command1' }, { commandName: 'failcommand', fails: true }]
	}
];
let groupMap: any;
let commandHelper: any;
const templateStub: SinonStub = stub();

const context = {
	testKey: 'testValue'
};

registerSuite('CommandHelper', {
	beforeEach() {
		templateStub.reset();
		mockery.enable({ warnOnUnregistered: false, useCleanCache: true });

		mockery.registerMock('./template', {
			default: templateStub
		});

		groupMap = getGroupMap(groupDef);
		const commandHelperCtor = require('../../src/CommandHelper').default;
		commandHelper = new commandHelperCtor(groupMap, context, configurationHelperFactory);
	},

	afterEach() {
		mockery.deregisterAll();
		mockery.disable();
	},

      it('should throw error if query.address and query.publicKey are empty', async () => {
        isEmptyStub.reset();
        isEmptyStub.returns(true);

        await expect(instance.getAccount(query)).to.be.rejectedWith('Missing required property: address or publicKey');
      });

		beforeEach((): void => {
			openDbStub.reset();
			callback.reset();
			DatabaseService["initialVersion"] = "";
		});

				rm: rmStub
			},
			fs: {
				chmodSync: chmodStub,
				existsSync: existsStub
			},
			'./process': {
				'exec': execStub,
				'spawn': spawnStub
			}
		};
		Publisher = loadModule('grunt-dojo2/tasks/util/Publisher', mocks);
	},

	beforeEach() {
		cpStub.reset();
		execStub.reset();
		spawnStub.reset();
		rmStub.reset();
		chmodStub.reset();
		existsStub.reset();
		log.writeln.reset();

		spawnStub.returns({
			stdout: 'result'
		});
	},

	teardown() {
		unloadTasks();
	},