it('passes readFiles results to file-reader', function () {
folderReader.readFiles.yields(null, ['a', 'b']);
reader.read('x/y/z', {}, function () {});
sinon.assert.calledTwice(fileReader.read);
sinon.assert.calledWith(fileReader.read, 'x/y/z/a');
sinon.assert.calledWith(fileReader.read, 'x/y/z/b');
});
it('rerenders after setting', function () {
const { controller, render } = init();
sinon.assert.notCalled(render);
controller.setCurrent('bar');
sinon.assert.calledOnce(render);
controller.setCurrent('bar');
sinon.assert.calledTwice(render);
});
it("should reload browser if once:true given as arg", function () {
var stream = browserSync.reload({stream: true, once: true});
stream.write(new File({path: "styles.css"}));
stream.write(new File({path: "styles2.css"}));
stream.write(new File({path: "styles3.css"}));
stream.end();
sinon.assert.calledTwice(emitterStub);
sinon.assert.calledWithExactly(emitterStub, "browser:reload");
});
setTimeout(function() {
expect(pkgLib.uninstall.calledOnce).to.be.true
expect(project.getConfig.calledOnce).to.be.true
expect(project.deleteDependency.calledOnce).to.be.true
sinon.assert.calledTwice(log.info)
expect(log.info.args[0][0]).to.match(/uninstalled foo/)
expect(log.info.args[1][0]).to.match(/removed foo/)
done()
}, 1)
.then(() => {
sinon.assert.calledOnce(req.logout);
sinon.assert.calledTwice(res.clearCookie);
sinon.assert.calledWith(res.clearCookie, 'access_token');
sinon.assert.calledWith(res.clearCookie, 'userId');
sinon.assert.calledOnce(res.redirect);
sinon.assert.calledWith(res.redirect, '/');
sinon.assert.notCalled(next);
});
t.test('respects backoff signals when writing', function (t) {
var stream = new EventEmitter();
var server = new StreamServer();
stream.write = sinon.stub();
stream.write.returns(false);
server.provide(function marco() { return 'polo'; });
server.listen(stream);
stream.emit('data', JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'marco'
}));
sinon.assert.calledOnce(stream.write);
sinon.assert.calledWith(stream.write, JSON.stringify({
jsonrpc: '2.0',
id: 1,
result: 'polo'
}));
stream.write.reset();
stream.emit('data', JSON.stringify({
jsonrpc: '2.0',
id: 2,
method: 'marco'
}));
stream.emit('data', JSON.stringify({
jsonrpc: '2.0',
id: 3,
method: 'marco'
}));
sinon.assert.notCalled(stream.write);
stream.write.returns(true);
stream.emit('drain');
sinon.assert.calledTwice(stream.write);
t.ok(stream.write.firstCall.calledWith(JSON.stringify({
jsonrpc: '2.0',
id: 2,
result: 'polo'
})));
t.ok(stream.write.secondCall.calledWith(JSON.stringify({
jsonrpc: '2.0',
id: 3,
result: 'polo'
})));
t.end();
});
it('should only trigger the change listener when something changes', function () {
const status = serverStatus.createForPlugin(plugin);
const stub = sinon.stub();
status.on('change', stub);
status.green('Ready');
status.green('Ready');
status.red('Not Ready');
sinon.assert.calledTwice(stub);
});
.then(function(resSave2) {
chai.expect(resSave2.abe_meta).to.not.be.undefined;
chai.expect(resSave2.abe_meta.link).to.be.equal('/article-2.html');
// unstub
abeExtend.hooks.instance.trigger.restore()
sinon.assert.calledTwice(Manager.instance.getList)
Manager.instance.getList.restore()
sinon.assert.calledTwice(coreUtils.slug.clean)
coreUtils.slug.clean.restore()
sinon.assert.calledTwice(coreUtils.array.filter)
coreUtils.array.filter.restore()
cmsData.file.get.restore()
sinon.assert.calledTwice(cmsOperations.create)
cmsOperations.create.restore()
sinon.assert.calledOnce(cmsOperations.remove.remove)
cmsOperations.remove.remove.restore()
done()
}.bind(this))
it('should initialze module when _shouldInit() is true', () => {
sinon.stub(dateTimeFormat, '_shouldInit').callsFake(() => true);
sinon.stub(dateTimeFormat, '_shouldReset').callsFake(() => false);
const checker = sinon.stub();
dateTimeFormat.store.subscribe(checker);
dateTimeFormat._onStateChange();
sinon.assert.calledTwice(checker);
expect(dateTimeFormat.store.getState().status).to.equal(moduleStatuses.ready);
expect(dateTimeFormat._defaultFormatter).to.be.a('function');
});
it('should clean up timeouts', function() {
var pingTimeout = socket.store.pingTimeout = 1
var pingReplyTimeout = socket.store.pingReplyTimeout = 2
sinon.stub(window, 'clearTimeout')
action()
sinon.assert.calledTwice(window.clearTimeout)
sinon.assert.calledWithExactly(window.clearTimeout, pingTimeout)
sinon.assert.calledWithExactly(window.clearTimeout, pingReplyTimeout)
window.clearTimeout.restore()
})
.then((resources) => {
sinon.assert.calledOnce(mockCompiledQueryBundle.execute);
sinon.assert.calledWith(mockCompiledQueryBundle.execute, mockDataService, 'Q1', { param1: true });
sinon.assert.calledTwice(mockAccessController.check);
sinon.assert.calledWith(mockAccessController.check, mockResource1, 'READ');
sinon.assert.calledWith(mockAccessController.check, mockResource2, 'READ');
resources.should.deep.equal([
{ $identifier: 'ASSET_1' }
]);
});
.then((resources) => {
sinon.assert.calledOnce(mockCompiledQueryBundle.execute);
sinon.assert.calledWith(mockCompiledQueryBundle.execute, mockDataService, '5769993d7c0a008e0cb45e30a36e3f2797c47c065be7f214c5dcee90419d326f', { param1: true });
sinon.assert.calledTwice(mockAccessController.check);
sinon.assert.calledWith(mockAccessController.check, mockResource1, 'READ');
sinon.assert.calledWith(mockAccessController.check, mockResource2, 'READ');
resources.should.deep.equal([
{ $identifier: 'ASSET_1' }
]);
});
it('should initialize two loan scenarios to their default values when there are currently no loans in the store', function() {
loanStore._loans = []; // So this will use common.loanCount = 2
loanStore.resetAllLoans();
sinon.assert.calledOnce(scenarioStore.getScenario);
sinon.assert.calledOnce(loanStore.updateDownpaymentConstant);
sinon.assert.calledTwice(loanStore.resetLoan);
expect(loanStore._loans).to.deep.equal([loan, loan])
});
it('should pass parameters to builds', () => {
settings.projects = ['org/repo1', 'org/repo2'];
requests.builds.returns(Rx.Observable.empty());
scheduler.startScheduler(() => travis.getLatest(settings));
sinon.assert.calledTwice(requests.builds);
sinon.assert.calledWith(requests.builds, 'org/repo1', settings);
sinon.assert.calledWith(requests.builds, 'org/repo2', settings);
});
it('emits change event when something changes after update call', function() {
var callback = sinon.spy();
eventEmitter.on('change', callback);
eventEmitter.update([]);
sinon.assert.notCalled(callback);
eventEmitter.update([
{ id: 'item1' },
{ id: 'item2' }
]);
sinon.assert.calledOnce(callback);
eventEmitter.update([]);
sinon.assert.calledTwice(callback);
eventEmitter.update([]);
sinon.assert.calledTwice(callback);
});
it('should call stepAnimation for each animation', () => {
Engine.runningAnimations = [
[{}, {}, {}],
[{}, {}, {}]
];
Engine.stepAnimations();
sinon.assert.calledTwice(Engine.stepAnimation);
});
it( 'should install missing dependencies', () => {
const dirs = [ 'ckeditor5-core', 'ckeditor5-devtest' ];
const installTask = sinon.spy();
spies.getDirectories = sinon.stub( tools, 'getCKE5Directories' ).returns( dirs );
spies.getCKE5Symlinks = sinon.stub( tools, 'getCKE5Symlinks' ).returns( [] );
const json = {
dependencies: {
'ckeditor5-core': 'ckeditor/ckeditor5-core',
'ckeditor5-devtest': 'ckeditor/ckeditor5-devtest#new-branch',
'ckeditor5-ui': 'ckeditor/ckeditor5-ui',
'other-plugin': '1.2.3'
}
};
updateTask( installTask, ckeditor5Path, json, workspaceRoot, true );
const repoPath1 = path.join( workspaceAbsolutePath, dirs[ 0 ] );
const repoPath2 = path.join( workspaceAbsolutePath, dirs[ 1 ] );
sinon.assert.calledThrice( spies.fetchAll );
sinon.assert.calledWithExactly( spies.fetchAll.firstCall, ckeditor5Path );
sinon.assert.calledWithExactly( spies.fetchAll.secondCall, repoPath1 );
sinon.assert.calledWithExactly( spies.fetchAll.thirdCall, repoPath2 );
sinon.assert.calledTwice( spies.checkout );
sinon.assert.calledWithExactly( spies.checkout.firstCall, repoPath1, 'master' );
sinon.assert.calledWithExactly( spies.checkout.secondCall, repoPath2, 'new-branch' );
sinon.assert.calledTwice( spies.pull );
sinon.assert.calledWithExactly( spies.pull.firstCall, repoPath1, 'master' );
sinon.assert.calledWithExactly( spies.pull.secondCall, repoPath2, 'new-branch' );
sinon.assert.calledThrice( spies.npmUpdate );
sinon.assert.calledWithExactly( spies.npmUpdate.firstCall, path.join( workspaceAbsolutePath, dirs[ 0 ] ) );
sinon.assert.calledWithExactly( spies.npmUpdate.secondCall, path.join( workspaceAbsolutePath, dirs[ 1 ] ) );
sinon.assert.calledWithExactly( spies.npmUpdate.thirdCall, ckeditor5Path );
sinon.assert.calledOnce( installTask );
sinon.assert.calledWithExactly( installTask, ckeditor5Path, workspaceRoot, 'ckeditor/ckeditor5-ui' );
sinon.assert.calledOnce( spies.getCKE5Symlinks );
sinon.assert.notCalled( spies.removeSymlink );
} );
it('should unregister listener when called', function () {
const listeners = [sinon.spy(), sinon.spy(), sinon.spy()];
const store = new Store();
const removeListeners = listeners
.map(listener => store.addListener(listener));
store.setState(0);
sinon.assert.calledOnce(listeners[0]);
sinon.assert.calledOnce(listeners[1]);
sinon.assert.calledOnce(listeners[2]);
// Remove second event listener.
removeListeners[1]();
store.setState(1);
sinon.assert.calledTwice(listeners[0]);
sinon.assert.calledOnce(listeners[1]);
sinon.assert.calledTwice(listeners[2]);
});
it('set the cfg twice, with force true',()=>{
let cfg = {
'logger': './winstonInjector.js',
'debug': 'composer[debug]:*',
'console': {
'maxLevel': 'error'
},
'file': {
'maxLevel': 'none'
}
};
sandbox.stub(Logger,'_loadLogger');
sandbox.stub(Logger,'_setupLog');
Logger.setLoggerCfg(cfg,true);
Logger.getLog('wibble');
Logger.setLoggerCfg(cfg,true);
sinon.assert.calledTwice(Logger._loadLogger);
sinon.assert.calledTwice(Logger._setupLog);
});
.then(() => {
sinon.assert.calledTwice(Login._read)
sinon.assert.calledWithExactly(
Login._read.secondCall,
{
prompt: 'GitHub password:'******'*'
}
)
})
.then(() => {
sinon.assert.calledTwice(Login._makeRequest)
sinon.assert.calledWithExactly(
Login._makeRequest.secondCall,
{
user: '******',
pass: '******'
},
'000000'
)
})
it('proccssExtension should be called twice when got two extensions', async () => {
const message = {
event: '/extension',
body: {
extensions: [{}, {}]
}
};
sinon.stub(accountExtension, '_processExtension');
await accountExtension._subscriptionHandleFn(message);
sinon.assert.calledTwice(accountExtension._processExtension);
});
it('works', function() {
stack._suites = [];
stack._updateSuiteName = sinon.stub();
stack.push('someSuite');
assert.deepEqual(stack._suites, ['someSuite']);
sinon.assert.calledOnce(stack._updateSuiteName);
stack.push('subSuite');
assert.deepEqual(stack._suites, ['someSuite', 'subSuite']);
sinon.assert.calledTwice(stack._updateSuiteName);
});
}, function (err, res) {
assert.ok(!err, err);
sinon.assert.calledOnce(localdbStub);
// this is called 2 times:
// - for sync connection
// - when calling fh.db
// - in fh.bootstrap
sinon.assert.calledTwice(databaseConnectionStringStub);
finish();
});
.then(function () {
sinon.assert.calledOnce(plugin.status.yellow);
expect(plugin.status.yellow.args[0][0]).to.be('Waiting for Elasticsearch');
sinon.assert.calledOnce(cluster.callWithInternalUser.withArgs('ping'));
sinon.assert.calledTwice(cluster.callWithInternalUser.withArgs('nodes.info', sinon.match.any));
sinon.assert.calledOnce(cluster.callWithInternalUser.withArgs('cluster.health', sinon.match.any));
sinon.assert.calledOnce(plugin.status.green);
expect(plugin.status.green.args[0][0]).to.be('Kibana index ready');
});
promise.then(function () {
expect(ctx.app.closingPromise).to.not.exist()
sinon.assert.calledTwice(ctx.app.consumerChannel.removeListener)
sinon.assert.calledWith(ctx.app.consumerChannel.removeListener, 'close', ctx.consumerCloseHandler)
sinon.assert.calledWith(ctx.app.consumerChannel.removeListener, 'error', ctx.consumerErrorHandler)
sinon.assert.calledOnce(ctx.app.consumerChannel.close)
sinon.assert.calledTwice(ctx.app.publisherChannel.removeListener)
sinon.assert.calledWith(ctx.app.publisherChannel.removeListener, 'close', ctx.producerCloseHandler)
sinon.assert.calledWith(ctx.app.publisherChannel.removeListener, 'error', ctx.producerErrorHandler)
sinon.assert.calledOnce(ctx.app.publisherChannel.close)
sinon.assert.calledOnce(ctx.app.connection.close)
sinon.assert.calledTwice(ctx.app.connection.removeListener)
sinon.assert.calledWith(ctx.app.connection.removeListener, 'close', ctx.connCloseHandler)
sinon.assert.calledWith(ctx.app.connection.removeListener, 'error', ctx.connErrorHandler)
sinon.assert.calledOnce(process.removeListener)
sinon.assert.calledWith(process.removeListener, 'SIGINT', ctx.sigintHandler)
sinon.assert.calledOnce(process.send)
sinon.assert.calledWith(process.send, { coworkersEvent: 'coworkers:close' })
done()
}).catch(done)
it('should reset module when _shouldReset() is true', () => {
sinon.stub(dateTimeFormat, '_shouldInit').callsFake(() => false);
sinon.stub(dateTimeFormat, '_shouldReset').callsFake(() => true);
dateTimeFormat.store.dispatch({
type: actionTypes.initSuccess,
});
const checker = sinon.stub();
dateTimeFormat.store.subscribe(checker);
dateTimeFormat._onStateChange();
sinon.assert.calledTwice(checker);
expect(dateTimeFormat.store.getState().status).to.equal(moduleStatuses.pending);
});
it('automatically creates the savedConfig if it is missing', async () => {
const { uiSettings, savedObjectsClient, createOrUpgradeSavedConfig } = setup();
savedObjectsClient.update
.onFirstCall()
.throws(savedObjectsClientErrors.createGenericNotFoundError())
.onSecondCall()
.returns({});
await uiSettings.setMany({ foo: 'bar' });
sinon.assert.calledTwice(savedObjectsClient.update);
sinon.assert.calledOnce(createOrUpgradeSavedConfig);
});
it('should upload the files in formdata mode correctly', function () {
sinon.assert.calledTwice(testrun.request);
sinon.assert.calledWith(testrun.request.getCall(0), null);
var resp = JSON.parse(testrun.response.getCall(0).args[2].stream.toString());
expect(resp.files).to.have.property('upload-file.json');
expect(resp).to.nested.include({
'headers.content-length': '253'
});
expect(resp.headers['content-type']).to.match(/multipart\/form-data/);
});
it('should call save method twice ', function () {
let user1 = new User({id: 1, name: 'testuser1'})
user.saveUser(user1, function () {
logger.info('user saved in DB.')
})
sinon.assert.calledOnce(save)
let user2 = new User({id: 2, name: 'testuser2'})
user.saveUser(user2, function () {
logger.info('user saved In DB.')
})
sinon.assert.calledTwice(save)
})