The Chances Are Nil

When I got really serious with my JavaScript and understood it well enough I always wanted to have some kind of unit testing framework. Unfortunately though there really does not seem to be anything available that really works and also has some kind of documentation on how to use it. I’ve been following JsUnit for a few year now but nobody seems to be using it. I tried using it myself over the years for mulitple times but like everyone else, I too seem to be lacking the necessary brain capacity to figure it out. So this weekend I incubated one myself and you know what? It’s not even that hard at all…

For my immediate testing needs it turned out I only needed two methods: areEqual and areEqualArrays. So I wrapped these into a Assert object:

[JavaScript]var Assert = {
areEqual: function(expected, actual, msg) {
if(expected != actual)
Kinky.fail(expected, actual, msg);
},
areEqualArrays: function(expected, actual, msg) {
if(expected.length != actual.length) {
Kinky.fail(expected, actual, msg);
return;
}
expected.each(function(item, index) {
Assert.areEqual(item, actual[index]);
});
}
}[/JavaScript]

As you can see the Assert object depends on the Kinky object so
let’s have that as well:

[JavaScript]var Kinky = {
failed: false,
output: new Alerter(),
fail: function(expected, actual, msg) {
if(this.failed) return;
this.failed = true;
this.output.writeLine(“Expected: ” + expected + “, was: ” + actual + “: ” + msg);
},
run: function(testFixture, output) {
if(output)
this.output = new Writer($(output));;

for(test in testFixture) {
testFixture[test]();
if(this.failed) return;
this.output.writeLine(test + ” done.”);
}
}
}[/JavaScript]

The last thing we need is the Alerter that’s referenced by the Kinky class:
[JavaScript]var Alerter = Class.create();
Alerter.prototype = {
initialize: function(beSilent) { this.beSilent = beSilent; },
writeLine: function(str) { if((!this.beSilent) || Kinky.failed) alert(str); }
}[/JavaScript]

The Alerter is somewhat a last-ditch effort to raise test messages. We usually want to have some more friendly output so we have this Writer class that’s able to redirect messages to document elements:

[JavaScript]var Writer = Class.create();
Writer.prototype = {
initialize: function(elm) { this.elm = elm; },
writeLine: function(str) { new Insertion.Bottom(this.elm, str + “
“); }
}[/JavaScript]

To have Kinky use it we need to assign it to Kinky.output like so:
[JavaScript]Kinky.output = new Writer($(‘theOutputElement’));[/JavaScript]

Or use the extended run function:
[JavaScript]Kinky.run(someTestFixture, ‘theOutputElement’);[/JavaScript]

The $ function is a Prototype function that returns the DOM node confirming to the id supplied. Continue reading “JavaScript”

A few year’s ago I was doing a graduation project at Philips Medical Systems together with a fellow student. Our task was to implement a browser interface to design flowcharts for work instructions. The content would be stored using their custom CMS. Eventually, our solution was based around a grid where each cell would define it’s own layout and could validate itself according to it’s neighbours in the grid. The whole thing was JavaScript based and persistence was handled by posting a dynamically created form to a PHP script.

Although we never got to fully clean up the implementation, the thing did work pretty well and was (and still is) pretty advanced JavaScript technology. It had to run in some kind of weird “template” system designed by the “guys that came before me” and that was pretty nasty but eventually we got stuff to work around and with that too.

Now, a few years later I had almost completely lost my touch with JavaScript if it wasn’t for a particular web-based problem we couldn’t “ViewState” our way out of. The client wanted drill down lookups and my boss wanted a generic solution. Our current solution is very generic but requires the users to postback at least a dozen times to get to the required lookup result. Although it works it rates pretty bad on the usability scales so now I’ve re-implemented the whole thing using JavaScript instead of relying on post-backs and .NET controls do to their job…

And mama, mia! What the #$ck have I been doing lately? Sleeping? Why don’t I use JavaScript in my projects anymore like I used to do… JavaScript kicks ass! Now that I’ve been from QBasic to Pascal to Assembler, Visual Basic, Delphi, Java, VBScript (ASP), C, C++, PHP, Python, Visual Basic.NET, C#, Smalltalk, Ruby and Lisp I can say that there are quite a few languages I would like to work with at the end of that list but that’s not an option right now unfortunately. Luckely though there’s JavaScript which allows me to do some amazing things… Even if it has to be in a browser. Continue reading “"JavaScript,”