OpenID for Node.js v0.4.2 released

The v0.4.2 release of OpenID for Node.js fixes a bug in DH response decoding and signature calculation which caused (seemingly random) failures in the shared secret computation. This again caused some valid authentications to be rejected as invalid by OpenID for Node.js. Please upgrade to the latest version of OpenID for Node.js to avoid potentially rejecting valid authentications for your users.

Details

The bug revealed two issues in the OpenID for Node.js library: * The unbtwoc routine which converts a received binary two’s complement number was flawed * The computed shared secret was not converted to binary two’s complement form before it was used to compute the signature

These two issues together caused some authentication attempts to be rejected.

Binding a DOM element to an observable using Knockout.js

I’ve been doing a bit of experimenting with Knockout.js recently. Having written quite a bit of .NET code over the years, I am very used to thinking in (and I prefer thinking in) the MVVM pattern when it comes to UIs, and so Knockout.js is nice.

And, as always, when writing code and living in the real world you sometimes need to do things that do not quite fit the pattern. In this case, I needed to draw on a canvas from my view model whenever some observables on it changed. The pragmatic thing to do when you need to draw on a canvas is to just grab the canvas by ID or whatever, but since this canvas lived in a template, identifying it through selectors quickly got messy (and hard).

Binding to it seemed like a much better idea, so I created the simple element Knockout.js binding. This is a one-way-to-source binding (.NET guys will be familiar with this terminology), meaning that the binding only writes to the view model from the view. In addition, the binding only does this once (when it is initialized), as the element will stay for the lifespan of the page.

So, in all its glory, here is my Knockout.js element binding:

ko.bindingHandlers.element = {
    init: function(element, valueAccessor) {
      var value = valueAccessor();
      value(element);
    }
};

Use it as you would any other binding:

<canvas width="100" height="60" data-bind="element: yourObservable"></canvas>

Simple as that. Now go use it!

On Continuous Testing, bling, and the quest for immediate feedback

My usual MO is not to engage in debates such as the recent heated HerdingCode/NCrunch vs Mighty Moose debate, but I can’t resist sharing my view regarding the issue at hand, as it concerns a tool I wrote called Continuous Testing for Visual Studio.

First of all, I want to emphasize that I think both of the aforementioned tools are great efforts, and most certainly provide value to those using them.

Second, the reason for being a passive listener is that I believe debates of this kind are utterly meaningless and provide no value whatsoever; making and improving the tools at hand is what provides value. I will make an exception this time as this debate (among other things) discusses a (if not the) fundamental motivation for writing Continuous Testing for Visual Studio, and highlights one of the significantly differentiating aspects of the approach it takes.

Third, and most importantly, the statement from the Herding Code podcast is objectively true. Put in even clearer words: It is impossible for a Continuous Testing tool to do static analysis and achieve perfect and correct test minimization. Even near perfect test minimization is impossible. The only generally possible thing is simple dependency resolution. Don’t let anyone tell you otherwise.

That is why Continuous Testing for Visual Studio does not do static analysis1, but relies purely on statistical heuristics to prioritize and give as immediate feedback as it possibly can, while still guaranteeing you the correct feedback.

Note the highlit words in the previous sentence. Immediate while correct. That is the core philosophy of Continuous Testing for Visual Studio. In the end, correct feedback matters infinitely much more than fast feedback when it comes to testing. Continuous Testing for Visual Studio tries to give you as immediate feedback as it can, while still giving you correct feedback.

It is up to you, dear reader, to try out the tools and find out which works best for you in your real world project. Try Continuous Testing for Visual Studio. While you do that, I’ll continue improving it.

1 We obviously do static analysis to resolve dependencies etc., but not for optimizing away tests.

Continuous Testing 2.0 is here

I am happy to announce the immediate availability of Continuous Testing 2.0 for Visual Studio 2010 and 2008.

From now on, Continuous Testing for Visual Studio will be available in two flavors: A full-featured Professional version and a free version staying more or less as it is today.

Continuous Testing 2.0 Buy Professional Download for VS2010 Download for VS 2008

The new Professional version features a number of improvements over the free version:

  • Smart Test Run Prioritization records the outcome of each of your tests, and orders the next test runs to minimize your wait for feedback even further. Smart Test Run Prioritization will run your tests in order of most recently failing and most often failing. This provides a significant speed-up for larger projects.
  • Abort on first failing test: You can choose to have Continuous Testing abort as soon as a test fails. This is useful for freeing up resources acquired by the test run as soon as feedback is available. This is another must-have feature in real world software development on large projects.
  • Priority support: Send an e-mail and get a response within 24 hours.

The combined features of Continous Testing Professional make for a very powerful and efficient TDD workflow.

Ensuring the last failing test runs first and aborting as soon as a test fails enables you to do as much as possible of what you are supposed to do: Write code.

The free version will continue to stay free with at least the current features. Here are the most notable new features of the free version:

  • A new integrated version of the test runners for MSTest and NUnit speeds up test runs. The executable test runners are still available. If you experience problems with running your tests using the integrated runners, try running your tests using the executable test runners instead.
  • Continuous Testing can be told to ignore specific projects when scanning for tests. This is useful if you are working on a solution with many test projects, and only want to run some of those projects.
  • Continuous Testing now has its own Output Window pane. Watch this pane to see what Continuous Testing is doing.

In addition, many improvements and bug fixes have made it into the release, ensuring a more stable and productive experience than before.

Happy testing and TDD-ing!

Introducing JSUT – Cross-platform JavaScript Unit Testing

I write quite a bit of JavaScript these days, and one observation I have made with regards to Line-of-Business apps is that platforms like Node.js makes me lean more towards sharing business logic between the server and client side (meaning Node.js and the browsers, in practice). This creates an immediate need to unit test “universally” (across all platforms and environments), and I couldn’t find a single tool that quite did it for me.

JSUT (JavaScript Unit Testing) is an attempt at making such a tool for fun and profit (non-monetary).

JSUT stems from me growing tired of the hurdles of unit testing my JavaScript code. There are tons of alternative unit testing tools and libraries readily available, but my experience was that they all exhibited one or more of the following shortcomings:

  • Imposing a “framework” or “philosophy” or “style” on my tests
  • Bringing me additional dependencies to worry about
  • Working only in the browser or inside Node.js

In addition, I feel that many of the available tools and libraries are either undermaintained or overly featureful, and buggy and/or painful to use as a result of one or both of those. I can’t and won’t claim that this will be different in the case of JSUT, so it’s not really an argument, but more a motivation for me.

Goals

I sat down and wrote a few goals for JSUT:

  • Universal, cross-platform
  • Minimalistic, simple, non-constraining
  • Accessible

I then took to writing code and brushing up my rather rusty shell scripting skills, and a few hours later I wound up with what I present to you now.

JSUT – JavaScript Unit Testing – An introduction

Writing a test in JSUT is about as simple as it can get. You write a function:

function myTest(test) {
  // JSUTs only requirement:
  // Call test.done() when the test is done
  test.done(); 
}

Now, let’s say you save this function to a file called test.js. You can then move to your preferred shell and write the following:

jsut -b chrome test.js

This will run your test in Chrome. To run your test in Node.js, do:

jsut -n test.js

You can combine the -b and -n flags any way you like, of course.

Getting JSUT

Getting JSUT is very simple. Assuming you have npm, just do:

npm install jsut

Which will install jsut locally. If you want a global installation, issue:

npm install jsut -g

Of course, with the goals for JSUT, you can also just download and copy deploy JSUT. Visit http://github.com/havard/jsut for source code and further instructions.

Requirements

As mentioned in the above sample, the only requirement JSUT imposes on you is to call test.done() when your test is done. Obviously, this seems redundant for the simple case of a synchronously executing function, but since most JavaScript functions these days are asynchronous at some level, there has to be a way to tell JSUT that a test is done. I am actively considering easing this requirement for simple cases, but this has not been a priority so far.

For Node.js, you are required to add the functions you want to test to the exports of each test file. Building on the example above, you can maintain cross-platform compatibility by doing the following:

if (typeof(exports) !== 'undefined') {
  exports.myTest = myTest;
}

This will add exports only if the exports variable is defined. Now, if you wanted to run your test in Node.js, you simply do:

jsut -n test.js

This will run your test in Node.js. You are free to combine the -n and -b flags any way you like, so that you can target all required platforms with a single command.

Assertions

JSUT automatically injects a CommonJS compatible assert module in your browser tests, so you can write stuff like assert.ok(true); anywhere in your test.

Planned features

JSUT currently only runs browser tests on OS X. I plan to support Linux and Windows as soon as possible. Follow me and JSUT on GitHub!