anorgatarrak-wordpress-theme/node_modules/hooker/test/hooker_test.js

436 lines
20 KiB
JavaScript

/*global require:true */
var hooker = require('../lib/hooker');
exports['hook'] = {
setUp: function(done) {
this.order = [];
this.track = function() {
[].push.apply(this.order, arguments);
};
this.prop = 1;
this.add = function(a, b) {
this.track("add", this.prop, a, b);
return this.prop + a + b;
};
this.obj = {
that: this,
prop: 1,
add1: function(a, b) {
this.that.track("add1", this.prop, a, b);
return this.prop + a + b;
},
add2: function(a, b) {
this.that.track("add2", this.prop, a, b);
return this.prop + a + b;
},
add3: function(a, b) {
this.that.track("add3", this.prop, a, b);
return this.prop + a + b;
}
};
done();
},
'orig': function(test) {
test.expect(1);
var orig = this.add;
hooker.hook(this, "add", function() {});
test.strictEqual(hooker.orig(this, "add"), orig, "should return a refernce to the original function.");
test.done();
},
'once': function(test) {
test.expect(5);
var orig = this.add;
hooker.hook(this, "add", {
once: true,
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
}
});
test.strictEqual(this.add(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", 1, 2, 3], "functions should execute in-order.");
test.strictEqual(this.add, orig, "should automatically unhook when once is specified.");
this.order = [];
test.strictEqual(this.add(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["add", 1, 2, 3], "only the original function should execute.");
test.done();
},
'pre-hook (simple syntax)': function(test) {
test.expect(3);
// Pre-hook.
var result = hooker.hook(this, "add", function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
});
test.deepEqual(result, ["add"], "add should have been hooked.");
test.strictEqual(this.add(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", 1, 2, 3], "functions should execute in-order.");
test.done();
},
'pre-hook': function(test) {
test.expect(3);
// Pre-hook.
var result = hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
}
});
test.deepEqual(result, ["add"], "add should have been hooked.");
test.strictEqual(this.add(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", 1, 2, 3], "functions should execute in-order.");
test.done();
},
'post-hook': function(test) {
test.expect(3);
// Post-hook.
var result = hooker.hook(this, "add", {
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
}
});
test.deepEqual(result, ["add"], "add should have been hooked.");
test.strictEqual(this.add(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["add", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
test.done();
},
'pre- & post-hook': function(test) {
test.expect(2);
// Pre- & post-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
}
});
test.strictEqual(this.add(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
test.done();
},
'pre-hook, return value override': function(test) {
test.expect(2);
// Pre-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// This return value will override the original function's return value.
return hooker.override("b" + this.prop + a + b);
}
});
test.strictEqual(this.add(2, 3), "b123", "should return the overridden result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", 1, 2, 3], "functions should execute in-order.");
test.done();
},
'post-hook, return value override': function(test) {
test.expect(2);
// Post-hook.
hooker.hook(this, "add", {
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
// This return value will override the original function's return value.
return hooker.override("a" + this.prop + a + b + result);
}
});
test.strictEqual(this.add(2, 3), "a1236", "should return the post-hook overridden result.");
test.deepEqual(this.order, ["add", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, return value override': function(test) {
test.expect(2);
// Pre- & post-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// This return value will override the original function's return value.
return hooker.override("b" + this.prop + a + b);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
// This return value will override the original function's return value
// AND the pre-hook's return value.
return hooker.override("a" + this.prop + a + b + result);
}
});
test.strictEqual(this.add(2, 3), "a1236", "should return the overridden result, and post-hook result should take precedence over pre-hook result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
test.done();
},
'pre-hook, filtering arguments': function(test) {
test.expect(2);
// Pre-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// Return hooker.filter(context, arguments) and they will be passed into
// the original function. The "track" and "order" propterites are just
// set here for the same of this unit test.
return hooker.filter({prop: "x", track: this.track, order: this.order}, ["y", "z"]);
}
});
test.strictEqual(this.add(2, 3), "xyz", "should return the original function's result, given filtered context and arguments.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", "x", "y", "z"], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, filtering arguments': function(test) {
test.expect(2);
// Pre- & post-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// Return hooker.filter(context, arguments) and they will be passed into
// the original function. The "track" and "order" propterites are just
// set here for the same of this unit test.
return hooker.filter({prop: "x", track: this.track, order: this.order}, ["y", "z"]);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
}
});
test.strictEqual(this.add(2, 3), "xyz", "should return the original function's result, given filtered context and arguments.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", "x", "y", "z", "after", 1, 2, 3, "xyz"], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, filtering arguments, return value override': function(test) {
test.expect(2);
// Pre- & post-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// Return hooker.filter(context, arguments) and they will be passed into
// the original function. The "track" and "order" propterites are just
// set here for the same of this unit test.
return hooker.filter({prop: "x", track: this.track, order: this.order}, ["y", "z"]);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
// This return value will override the original function's return value
// AND the pre-hook's return value.
return hooker.override("a" + this.prop + a + b + result);
}
});
test.strictEqual(this.add(2, 3), "a123xyz", "should return the post-hook overridden result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add", "x", "y", "z", "after", 1, 2, 3, "xyz"], "functions should execute in-order.");
test.done();
},
'pre-hook, preempt original function': function(test) {
test.expect(2);
// Pre-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// Returning hooker.preempt will prevent the original function from being
// invoked and optionally set a return value.
return hooker.preempt();
}
});
test.strictEqual(this.add(2, 3), undefined, "should return the value passed to preempt.");
test.deepEqual(this.order, ["before", 1, 2, 3], "functions should execute in-order.");
test.done();
},
'pre-hook, preempt original function with value': function(test) {
test.expect(2);
// Pre-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// Returning hooker.preempt will prevent the original function from being
// invoked and optionally set a return value.
return hooker.preempt(9000);
}
});
test.strictEqual(this.add(2, 3), 9000, "should return the value passed to preempt.");
test.deepEqual(this.order, ["before", 1, 2, 3], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, preempt original function with value': function(test) {
test.expect(2);
// Pre- & post-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// Returning hooker.preempt will prevent the original function from being
// invoked and optionally set a return value.
return hooker.preempt(9000);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
}
});
test.strictEqual(this.add(2, 3), 9000, "should return the value passed to preempt.");
test.deepEqual(this.order, ["before", 1, 2, 3, "after", 1, 2, 3, 9000], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, preempt original function with value, return value override': function(test) {
test.expect(2);
// Pre- & post-hook.
hooker.hook(this, "add", {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.track("before", this.prop, a, b);
// Returning hooker.preempt will prevent the original function from being
// invoked and optionally set a return value.
return hooker.preempt(9000);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.track("after", this.prop, a, b, result);
// This return value will override any preempt value set in pre-hook.
return hooker.override("a" + this.prop + a + b + result);
}
});
test.strictEqual(this.add(2, 3), "a1239000", "should return the overridden result, and post-hook result should take precedence over preempt value.");
test.deepEqual(this.order, ["before", 1, 2, 3, "after", 1, 2, 3, 9000], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, some properties': function(test) {
test.expect(7);
// Pre- & post-hook.
var result = hooker.hook(this.obj, ["add1", "add2"], {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.that.track("before", this.prop, a, b);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.that.track("after", this.prop, a, b, result);
}
});
test.deepEqual(result.sort(), ["add1", "add2"], "both functions should have been hooked.");
test.strictEqual(this.obj.add1(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add1", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
this.order = [];
test.strictEqual(this.obj.add2(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add2", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
this.order = [];
test.strictEqual(this.obj.add3(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["add3", 1, 2, 3], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, all properties': function(test) {
test.expect(7);
// Pre- & post-hook.
var result = hooker.hook(this.obj, {
pre: function(a, b) {
// Arguments are passed into pre-hook as specified.
this.that.track("before", this.prop, a, b);
},
post: function(result, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.that.track("after", this.prop, a, b, result);
}
});
test.deepEqual(result.sort(), ["add1", "add2", "add3"], "all functions should have been hooked.");
test.strictEqual(this.obj.add1(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add1", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
this.order = [];
test.strictEqual(this.obj.add2(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add2", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
this.order = [];
test.strictEqual(this.obj.add3(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, 2, 3, "add3", 1, 2, 3, "after", 1, 2, 3, 6], "functions should execute in-order.");
test.done();
},
'pre- & post-hook, all properties, passName': function(test) {
test.expect(6);
// Pre- & post-hook.
hooker.hook(this.obj, {
passName: true,
pre: function(name, a, b) {
// Arguments are passed into pre-hook as specified.
this.that.track("before", this.prop, name, a, b);
},
post: function(result, name, a, b) {
// Arguments to post-hook are the original function's return value,
// followed by the specified function arguments.
this.that.track("after", this.prop, name, a, b, result);
}
});
test.strictEqual(this.obj.add1(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, "add1", 2, 3, "add1", 1, 2, 3, "after", 1, "add1", 2, 3, 6], "functions should execute in-order.");
this.order = [];
test.strictEqual(this.obj.add2(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, "add2", 2, 3, "add2", 1, 2, 3, "after", 1, "add2", 2, 3, 6], "functions should execute in-order.");
this.order = [];
test.strictEqual(this.obj.add3(2, 3), 6, "should return the original function's result.");
test.deepEqual(this.order, ["before", 1, "add3", 2, 3, "add3", 1, 2, 3, "after", 1, "add3", 2, 3, 6], "functions should execute in-order.");
test.done();
},
'unhook one property': function(test) {
test.expect(5);
var orig = this.add;
hooker.hook(this, "add", function() {});
var result = hooker.unhook(this, "add");
test.deepEqual(result, ["add"], "one function should have been unhooked.");
test.strictEqual(this.add, orig, "should have unhooked, restoring the original function");
result = hooker.unhook(this, "add");
test.deepEqual(result, [], "nothing should have been unhooked.");
test.strictEqual(this.add, orig, "shouldn't explode if already unhooked");
test.strictEqual(this.add.orig, undefined, "original function shouldn't have an orig property");
test.done();
},
'unhook some properties': function(test) {
test.expect(6);
var add1 = this.obj.add1;
var add2 = this.obj.add2;
hooker.hook(this.obj, ["add1", "add2"], function() {});
test.strictEqual(hooker.orig(this.obj, "add1"), add1, "should return a refernce to the original function");
test.strictEqual(hooker.orig(this.obj, "add2"), add2, "should return a refernce to the original function");
test.strictEqual(hooker.orig(this.obj, "add3"), undefined, "should not have been hooked, so should not have an original function");
var result = hooker.unhook(this.obj, ["add1", "add2"]);
test.deepEqual(result.sort(), ["add1", "add2"], "both functions should have been unhooked.");
test.strictEqual(this.obj.add1, add1, "should have unhooked, restoring the original function");
test.strictEqual(this.obj.add2, add2, "should have unhooked, restoring the original function");
test.done();
},
'unhook all properties': function(test) {
test.expect(7);
var add1 = this.obj.add1;
var add2 = this.obj.add2;
var add3 = this.obj.add3;
hooker.hook(this.obj, function() {});
test.strictEqual(hooker.orig(this.obj, "add1"), add1, "should return a refernce to the original function");
test.strictEqual(hooker.orig(this.obj, "add2"), add2, "should return a refernce to the original function");
test.strictEqual(hooker.orig(this.obj, "add3"), add3, "should return a refernce to the original function");
var result = hooker.unhook(this.obj);
test.deepEqual(result.sort(), ["add1", "add2", "add3"], "all functions should have been unhooked.");
test.strictEqual(this.obj.add1, add1, "should have unhooked, restoring the original function");
test.strictEqual(this.obj.add2, add2, "should have unhooked, restoring the original function");
test.strictEqual(this.obj.add3, add3, "should have unhooked, restoring the original function");
test.done();
}
};