QUnit.test("debounce - handles multiple batches", function() {
var obj = assign({}, canEvent);
var count = 0;
obj.on("event", canBatch.debounce(function(event, arg1, arg2) {
ok(true, "event run");
count++;
if (count === 1) {
equal(arg1, 7);
equal(arg2, 8);
}
if (count === 2) {
equal(arg1, 10);
equal(arg2, 11);
}
}));
expect(6);
canBatch.start();
obj.dispatch("event", [ 5, 6 ]);
obj.dispatch("event", [ 7, 8 ]);
canBatch.stop();
canBatch.start();
obj.dispatch("event", [ 9, 0 ]);
obj.dispatch("event", [ 10, 11 ]);
canBatch.stop();
});
QUnit.test("basics", function(){
var collecting;
var secondFired = false;
var obj = assign({}, canEvent);
obj.on("first", function(ev, arg1, arg2){
QUnit.equal(collecting.number, ev.batchNum, "same batch num");
QUnit.equal(canBatch.dispatching(), collecting, "dispatching old collecting");
QUnit.equal(arg1, 1, "first arg");
QUnit.equal(arg2, 2, "second arg");
collecting = canBatch.collecting();
QUnit.ok(!collecting, "not collecting b/c we're not in a batch yet");
obj.dispatch("second");
collecting = canBatch.collecting();
QUnit.ok(collecting, "forced a batch");
QUnit.equal(secondFired, false, "don't fire yet, put in next batch");
});
obj.on("second", function(ev){
secondFired = true;
QUnit.equal(collecting.number, ev.batchNum, "same batch num on second");
QUnit.equal(canBatch.dispatching(), collecting, "dispatching second collecting");
});
canBatch.start();
collecting = canBatch.collecting();
QUnit.ok(canBatch.collecting(), "is collecting");
obj.dispatch("first",[1,2]);
canBatch.stop();
});
QUnit.test("flushing a future batch (#18)", function(){
var firstFired, secondFired, thirdFired;
var obj = assign({}, canEvent);
obj.on("first", function(){
canBatch.start();
obj.dispatch("second");
obj.dispatch("third");
canBatch.stop();
canBatch.flush();
QUnit.ok(firstFired, "first fired");
QUnit.ok(secondFired, "second fired");
QUnit.ok(thirdFired, "third fired");
});
obj.on("first", function(){
firstFired = true;
});
obj.on("second", function(){
secondFired = true;
});
obj.on("third", function(){
thirdFired = true;
});
canBatch.start();
obj.dispatch("first");
canBatch.stop();
});
QUnit.test("shorthand getter (#56)", function() {
var Person = function(first, last) {
this.first = first;
this.last = last;
};
define(Person.prototype, {
first: "*",
last: "*",
get fullName() {
return this.first + " " + this.last;
}
});
var p = new Person("Mohamed", "Cherif");
p.on("fullName", function(ev, newVal, oldVal) {
QUnit.equal(oldVal, "Mohamed Cherif");
QUnit.equal(newVal, "Justin Meyer");
});
equal(p.fullName, "Mohamed Cherif", "fullName initialized right");
canBatch.start();
p.first = "Justin";
p.last = "Meyer";
canBatch.stop();
});
suite.add( "can-stache spinning circles", function() {
canBatch.start();
for ( var n = 0; n < boxes.length; n++ ) {
boxes[ n ].tick();
}
canBatch.stop();
}, {
defineExpando: function(map, prop, value) {
// first check if it's already a constructor define
var constructorDefines = map._define.definitions;
if(constructorDefines && constructorDefines[prop]) {
return;
}
// next if it's already on this instances
var instanceDefines = map._instanceDefinitions;
if(!instanceDefines) {
instanceDefines = map._instanceDefinitions = {};
}
if(!instanceDefines[prop]) {
var defaultDefinition = map._define.defaultDefinition || {type: define.types.observable};
define.property(map, prop, defaultDefinition, {},{});
// possibly convert value to List or DefineMap
map._data[prop] = defaultDefinition.type ? defaultDefinition.type(value) : define.types.observable(value);
instanceDefines[prop] = defaultDefinition;
canBatch.start();
canEvent.dispatch.call(map, {
type: "__keys",
target: map
});
if(map._data[prop] !== undefined) {
canEvent.dispatch.call(map, {
type: prop,
target: map
},[map._data[prop], undefined]);
}
canBatch.stop();
return true;
}
},
behavior[funcName+"Instance"] = function (instance, props) {
var constructor = instance.constructor;
// Update attributes if attributes have been passed
if(props && typeof props === 'object') {
if("attr" in instance) {
instance.attr(isFunction(props.attr) ? props.attr() : props, this.constructor.removeAttr || false);
} else {
canBatch.start();
each(props, function(value, prop){
instance[prop] = value;
});
canBatch.stop();
}
}
// triggers change event that bubble's like
// handler( 'change','1.destroyed' ). This is used
// to remove items on destroyed from Model Lists.
// but there should be a better way.
canEvent.dispatch.call(instance, {type:funcName, target: instance});
//!steal-remove-start
dev.log("can-connect/can/map/map.js - " + (constructor.shortName || this.name) + " " + this.id(instance) + " " + funcName);
//!steal-remove-end
// Call event on the instance's Class
canEvent.dispatch.call(constructor, funcName, [instance]);
};
_setAttrs: function (items, remove) {
// Create a copy.
items = makeArray(items);
canBatch.start();
this._updateAttrs(items, remove);
canBatch.stop();
},
QUnit.test("debounce - only triggers if event was triggered", function() {
var obj = assign({}, canEvent);
obj.on("event", canBatch.debounce(function() {
ok(true, "event run");
}));
expect(1);
canBatch.start();
obj.dispatch("event");
obj.dispatch("event");
canBatch.stop();
canBatch.start();
obj.dispatch("foo");
obj.dispatch("foo");
canBatch.stop();
});
obj.on("first", function(){
canBatch.start();
obj.dispatch("second");
obj.dispatch("third");
canBatch.stop();
canBatch.flush();
QUnit.ok(firstFired, "first fired");
QUnit.ok(secondFired, "second fired");
QUnit.ok(thirdFired, "third fired");
});
splice: function (index, howMany) {
var args = makeArray(arguments),
added =[],
i, len, listIndex,
allSame = args.length > 2;
index = index || 0;
// converting the arguments to the right type
for (i = 0, len = args.length-2; i < len; i++) {
listIndex = i + 2;
args[listIndex] = this.__type(args[listIndex], listIndex);
added.push(args[listIndex]);
// Now lets check if anything will change
if(this[i+index] !== args[listIndex]) {
allSame = false;
}
}
// if nothing has changed, then return
if(allSame && this.length <= added.length) {
return added;
}
// default howMany if not provided
if (howMany === undefined) {
howMany = args[1] = this.length - index;
}
var removed = splice.apply(this, args);
// delete properties for browsers who's splice sucks (old ie)
if (!spliceRemovesProps) {
for (i = this.length; i < removed.length + this.length; i++) {
delete this[i];
}
}
canBatch.start();
if (howMany > 0) {
// tears down bubbling
bubble.removeMany(this, removed);
this._triggerChange("" + index, "remove", undefined, removed);
}
if (args.length > 2) {
// make added items bubble to this list
bubble.addMany(this, added);
this._triggerChange("" + index, "add", added, removed);
}
canBatch.stop();
return removed;
},
QUnit.test("afterPreviousEvents doesn't run after all collecting previous events (#17)", function(){
var obj = assign({}, canEvent);
var afterPreviousEventsFired = false;
obj.on("first", function(){
QUnit.ok(!afterPreviousEventsFired, "after previous should fire after");
});
canBatch.start();
obj.dispatch("first");
canBatch.afterPreviousEvents(function(){
afterPreviousEventsFired = true;
});
canBatch.stop();
});
QUnit.test("debounce - basics (#3)", function() {
var obj = assign({}, canEvent);
obj.on("event", canBatch.debounce(function(event, arg1, arg2) {
ok(true, "event run");
equal(arg1, 3);
equal(arg2, 4);
}));
expect(3);
canBatch.start();
obj.dispatch("event", [ 1, 2 ]);
obj.dispatch("event", [ 3, 4 ]);
canBatch.stop();
});
QUnit.test("missing stop should logs a Warning Timeout", function(){
var oldMissingStopWarningTimeout = canBatch.missingStopWarningTimeout;
canBatch.missingStopWarningTimeout = 1000;
var oldWarn = canDev.warn;
QUnit.stop();
canDev.warn = function() {
QUnit.start();
ok(true, "received warning");
canBatch.missingStopWarningTimeout = oldMissingStopWarningTimeout;
canDev.warn = oldWarn;
canBatch.stop();
};
var obj = assign({}, canEvent);
canBatch.start();
obj.dispatch("anEvent");
});
QUnit.test("events are queued and dispatched without .stop being called (#14)", function(){
var obj = assign({}, canEvent);
obj.on("first", function(ev){
obj.dispatch("second");
QUnit.ok(canBatch.collecting() !== canBatch.dispatching(), "dispatching is not collecting");
});
obj.on("second", function(){
QUnit.ok(canBatch.collecting() !== canBatch.dispatching(), "dispatching is not collecting");
QUnit.ok(true, "called");
});
canBatch.start();
obj.dispatch("first");
canBatch.stop();
});
QUnit.test("batchNumber is set by .dispatch that has a batchNum",function(){
var obj = assign({}, canEvent);
var firstBN;
obj.on("first", function(ev){
firstBN =ev.batchNum;
canEvent.flush();
obj.dispatch({type: "second", batchNum: ev.batchNum});
});
obj.on("second", function(ev){
QUnit.equal(firstBN,ev.batchNum,"batch num set");
QUnit.equal(canBatch.batchNum,ev.batchNum,"batch num set");
});
canBatch.start();
obj.dispatch("first");
canBatch.stop();
});
QUnit.test("basics on a prototype", 5, function() {
var Person = function(first, last) {
this.first = first;
this.last = last;
};
define(Person.prototype, {
first: "*",
last: "*",
fullName: {
get: function() {
return this.first + " " + this.last;
}
}
});
var p = new Person("Mohamed", "Cherif");
p.bind("fullName", function(ev, newVal, oldVal) {
QUnit.equal(oldVal, "Mohamed Cherif");
QUnit.equal(newVal, "Justin Meyer");
});
equal(p.fullName, "Mohamed Cherif", "fullName initialized right");
p.bind("first", function(el, newVal, oldVal) {
QUnit.equal(newVal, "Justin", "first new value");
QUnit.equal(oldVal, "Mohamed", "first old value");
});
canBatch.start();
p.first = "Justin";
p.last = "Meyer";
canBatch.stop();
});
updatedList: function(){
canBatch.start();
var res = baseConnect.updatedList.apply(this, arguments);
canBatch.stop();
return res;
},