The case of the mysterious failing date test

I had such an aha! moment this afternoon that I thought I'd share it.

This test case was failing for me, and I was positive that I hadn't made any changes which would affect that part of the system:

	import static org.fest.assertions.api.Assertions.assertThat;
	import java.util.Date;
	import org.joda.time.DateTime;
	import org.joda.time.Interval;
	import org.junit.After;
	import org.junit.Before;
	import org.junit.Test;
	import org.quartz.Trigger;
	import com.fiestacabin.dropwizard.quartz.ManagedScheduler;
	import com.fiestacabin.dropwizard.quartz.Scheduled;
	public class MyFailingDateTest {
	@Test
	public void shouldFireDaily() throws Exception {
	// @Scheduled(cron="0 0 0 * * ?")
	Scheduled s = PasswordExpirationJob.class.getAnnotation(Scheduled.class);
	Trigger t = ManagedScheduler.buildTrigger(s);
	Date start = t.getStartTime();
	Date next = t.getFireTimeAfter(start);
	start = next;
	next = t.getFireTimeAfter(start);
	Interval i = new Interval(start.getTime(), next.getTime());
	assertThat(i.toDuration().getStandardDays()).isEqualTo(1);
	}
	}

view raw FailingDateTest.java hosted with ❤ by GitHub

The trick here is when I was running the test: March 9, 2013, at 1:55pm EST. Turns out that tonight is daylight savings, when we "spring ahead" and lose an hour, and of course 23 hours does not a standard day make!

Using StealJS in Jasmine Tests with Grunt

Grunt Jasmine Configuration

In this post, I'll detail how to use StealJS to author Javascript unit tests in Jasmine, and run them from the command line using the headless grunt-contrib-jasmine runner.

If you look in the documentation for grunt-contrib-jasmine, you'll see a section on using a custom template to run tests which use RequireJS as a dependency manager. You'll end up doing the same bit for StealJS, but will use a different template plugin: grunt-template-jasmine-steal.

First, install the necessary plugins into your local grunt project workspace:

npm install grunt-contrib-jasmine --save-dev
npm install grunt-template-jasmine-steal --save-dev

Next, import the tasks into your Gruntfile.js:

grunt.loadNpmTasks('grunt-contrib-jasmine');
grunt.registerTask('test', ['connect:test', 'jasmine']);

Finally, define the connect and jasmine plugin configs. Note that I'm setting up the connect plugin to start a local web server on port 8000, for phantomjs to connect to when running the jasmine suite:

var jsFiles = [
    'src/**/*.js',
    '!src/can/**/*.js',
    '!src/steal/**/*.js',
    '!src/thirdparty/**/*.js'
];

connect: {
    test : {
        port : 8000
    }
},

jasmine: {
    tests: {
        src: jsFiles,
        options: {
            specs: 'src/**/*_spec.js',
            host: 'http://127.0.0.1:8000/',
            template: require('grunt-template-jasmine-steal'),
            templateOptions: {
                stealOptions: {
                    stealUrl: '/src/steal/steal.js',
                    baseUrl: ''
                }
            }
        }
    }
}

Take note of the jsFiles variable I defined; that concisely lists all of my javascript source files, excluding libraries.

Cleaning and Linting your Sources

Another important build step is to clean and lint (error check and validate) your code, and thankfully grunt makes this easy on us. I use the jsbeautifier and grunt-contrib-jshint plugins for this:

grunt.loadNpmTasks('grunt-jsbeautifier');

grunt.loadNpmTasks('grunt-contrib-jshint');

        jsbeautifier : {

          files : jsFiles

        },

        jshint: {

            files: jsFiles,

            options: {

                jshintrc: '.jshintrc'

            },

        },

Note: look at the documentation for jsbeautifier to see the available configuration options (the defaults work fine for me out of the box).

Putting it All Together

Here is a complete Gruntfile.js and .jshintrc, detailing what I went through in detail above. I've set it so that the default grunt task performs the code formatting, checks using jshint, and then runs the full jasmine test suite.

	/*global module:false */
	module.exports = function (grunt) {
	var jsFiles = [
	'src/**/*.js',
	'!src/can/**/*.js',
	'!src/steal/**/*.js',
	'!src/thirdparty/**/*.js'
	];
	// Project configuration.
	grunt.initConfig({
	pkg: grunt.file.readJSON('package.json'),
	jsbeautifier : {
	files : jsFiles
	},
	jshint: {
	files: jsFiles,
	options: {
	jshintrc: '.jshintrc'
	},
	},
	connect: {
	test : {
	port : 8000
	}
	},
	jasmine: {
	tests: {
	src: jsFiles,
	options: {
	specs: 'src/**/*_spec.js',
	host: 'http://127.0.0.1:8000/',
	template: require('grunt-template-jasmine-steal'),
	templateOptions: {
	stealOptions: {
	stealUrl: '/src/steal/steal.js',
	baseUrl: ''
	}
	}
	}
	}
	},
	clean: {
	all: ['target'],
	prepackage: ['target/src/steal/build', 'target/src/steal/rhino']
	},
	copy: {
	build: {
	files: {
	'target/': ['src/**/*.html']
	},
	options: {
	processContent: function (content) {
	return content.replace(/env\s*: 'development', \/\/ live/g, "env: 'production',").replace(/\$\{project\.version\}/g, grunt.template.process('<%= pkg.version %>'));
	}
	}
	},
	build_other: {
	files: {
	'target/': ['src/**/*', 'src/**/.*', '!src/**/*.html']
	}
	}
	},
	shell: {
	chmodjs: {
	command: 'chmod 755 target/src/js'
	},
	steal_app: {
	command: './js app/scripts/build.js',
	options: {
	stdout: true,
	stderr: true,
	failOnError: true,
	execOptions: {
	cwd: 'target/src'
	}
	}
	}
	},
	exists: {
	prod_files: [
	'target/src/app/production.js',
	'target/src/app/production.css'
	]
	},
	compress: {
	zip: {
	options: {
	archive: 'target/app-ui-<%= pkg.version %>.zip'
	},
	files: [
	{expand: true, cwd: 'target/src/', src: ['**'], dest: '/'},
	{expand: true, cwd: 'target/src/', src: ['.*'], dest: '/'}
	]
	}
	}
	});
	grunt.loadNpmTasks('grunt-contrib-clean');
	grunt.loadNpmTasks('grunt-contrib-compress');
	grunt.loadNpmTasks('grunt-contrib-connect');
	grunt.loadNpmTasks('grunt-contrib-copy');
	grunt.loadNpmTasks('grunt-contrib-jshint');
	grunt.loadNpmTasks('grunt-contrib-jasmine');
	grunt.loadNpmTasks('grunt-shell');
	grunt.loadNpmTasks('grunt-exists');
	grunt.loadNpmTasks('grunt-jsbeautifier');
	grunt.loadNpmTasks('grunt-wisdom');
	grunt.registerTask('default', ['test', 'wisdom']);
	grunt.registerTask('check', ['jsbeautifier', 'jshint']);
	grunt.registerTask('test', ['check', 'connect:test', 'jasmine']);
	grunt.registerTask('build', ['test', 'clean:all', 'copy', 'shell', 'clean:prepackage', 'exists', 'compress']);
	};

view raw Gruntfile.js hosted with ❤ by GitHub

	{
	"name": "app-ui",
	"version": "1.0.0",
	"devDependencies": {
	"grunt": "~0.4.0",
	"grunt-contrib-clean": "~0.4.0",
	"grunt-contrib-compress": "~0.4.1",
	"grunt-contrib-copy": "~0.4.0",
	"grunt-contrib-jshint": "~0.1.1",
	"grunt-exists": "~0.0.2",
	"grunt-jsbeautifier": "~0.1.5",
	"grunt-wisdom": "~0.0.3",
	"grunt-shell": "~0.2.1",
	"grunt-contrib-jasmine": "~0.3.3",
	"grunt-template-jasmine-steal": "~0.1.0",
	"grunt-contrib-connect": "~0.1.2"
	},
	"engines": {
	"node": ">=0.8"
	}
	}

view raw package.json hosted with ❤ by GitHub

	{
	"bitwise": false,
	"camelcase": false,
	"curly": false,
	"eqeqeq": true,
	"forin": true,
	"immed": true,
	"indent": false,
	"latedef": true,
	"newcap": false,
	"noarg": true,
	"noempty": true,
	"nonew": true,
	"plusplus": false,
	"quotmark": false,
	"regexp": true,
	"undef": true,
	"unused": true,
	"strict": false,
	"trailing": true,
	"maxparams": false,
	"maxdepth": false,
	"maxcomplexity": false,
	"asi": true,
	"boss": false,
	"debug": false,
	"eqnull": false,
	"es5": false,
	"esnext": false,
	"evil": false,
	"expr": true,
	"funcscope": false,
	"globalstrict": false,
	"iterator": false,
	"lastsemic": false,
	"laxbreak": false,
	"laxcomma": false,
	"loopfunc": false,
	"multistr": false,
	"onecase": false,
	"proto": false,
	"regexdash": false,
	"scripturl": false,
	"smarttabs": false,
	"shadow": false,
	"sub": false,
	"supernew": false,
	"validthis": false,
	"browser": true,
	"jquery": true,
	"white": false,
	"globals": {
	"steal": false,
	"can": false,
	"load": false,
	"alert": false,
	"confirm": false,
	"_currentUser": true,
	"describe": false,
	"it": false,
	"expect": false,
	"beforeEach": false,
	"spyOn": false
	}
	}

view raw gistfile1.json hosted with ❤ by GitHub

A deferred loading cache in Javascript

I was playing around with jQuery deferreds the other day, and thought up a neat use for them, in a client-side ajax response cache. I created a simple expiring cache abstraction, and then wrote a 'loading' cache around it, which populates the cache with $.Deferred instances which are resolved with the result of a $.get.

Here's the simple expiring cache:

	steal(function() {
	function ExpiringCache(options) {
	if (!(this instanceof ExpiringCache)) {
	return new ExpiringCache(options);
	}
	this._items = {};
	this._size = 0;
	this._defaultExpiry = options ? options.defaultExpiry : 60 * 1000;
	}
	ExpiringCache.prototype.get = function(key) {
	var item = this._items[key];
	if (item) {
	if (new Date() - item.ctime >= item.expiry) {
	delete this._items[key];
	this._size--;
	return null;
	}
	}
	return item ? item.val : null;
	};
	ExpiringCache.prototype.put = function(key, val, expiry) {
	var item = this.get(key);
	this._items[key] = {
	ctime: new Date().getTime(),
	expiry: expiry || this._defaultExpiry,
	val: val
	}
	if (!item) {
	this._size++;
	}
	return item;
	};
	ExpiringCache.prototype.remove = function(key) {
	var item = this.get(key);
	if (item) {
	delete this._items[key];
	this._size--;
	}
	return item;
	};
	ExpiringCache.prototype.size = function() {
	return this._size;
	}
	window.ExpiringCache = ExpiringCache;
	})

view raw expiring_cache.js hosted with ❤ by GitHub

And here's the deferred loading cache:

	/*global ExpiringCache:false */
	steal('jquery', 'expiring_cache.js', function() {
	function LoadingCache() {
	this.cache = new ExpiringCache();
	}
	LoadingCache.prototype.load = function(path) {
	var item = this.cache.get(path);
	if (!item) {
	item = $.Deferred();
	this.cache.put(path, item);
	}
	if (item.state() !== 'resolved') {
	$.get(path, function(data) {
	item.resolve(data);
	});
	}
	return item;
	};
	window.LoadingCache = LoadingCache;
	});

view raw loading_cache.js hosted with ❤ by GitHub

Jasmine spec for the loading cache:

	/*global LoadingCache:false */
	steal('app/util/loading_cache.js', function() {
	describe("loading cache", function() {
	var cache;
	beforeEach(function() {
	spyOn(jQuery, 'get');
	cache = new LoadingCache();
	})
	it('returns deferred for non-existent entry', function() {
	var item = cache.load('foo');
	expect('resolve' in item).toBeTruthy();
	expect(item.state()).not.toEqual('resolved');
	})
	it('invokes $.get with given path for unloaded entry', function() {
	cache.load('foo');
	expect(jQuery.get).toHaveBeenCalled();
	expect(jQuery.get.calls[0].args[0]).toEqual('foo');
	})
	it('resolves the item deferred with the result of the $.get', function() {
	var item = cache.load('foo'),
	fn = jQuery.get.calls[0].args[1];
	fn('bar');
	expect(item.state()).toEqual('resolved');
	item.done(function(val) {
	expect(val).toEqual('bar');
	})
	})
	it('doesnt call $.get again for resolved entry', function() {
	cache.load('foo');
	var fn = jQuery.get.calls[0].args[1];
	fn('bar');
	cache.load('foo');
	expect(jQuery.get.calls.length).toBe(1);
	})
	})
	})

view raw loading_cache_spec.js hosted with ❤ by GitHub

In my next post, I'll show how to use a jasmine spec runner for steal to run jasmine steal specs in grunt.