Fixed many permissions and began admin interface

18 files changed, 4503 insertions, 0 deletions

diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/calendar-weeks.js b/public/bower_components/bootstrap-datepicker/tests/suites/calendar-weeks.js
new file mode 100644
index 0000000..258c29c
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/calendar-weeks.js
@@ -0,0 +1,48 @@
+module('Calendar Weeks', {
+    setup: function(){
+        this.input = $('<input type="text">')
+            .appendTo('#qunit-fixture')
+            .val('2013-01-14')
+            .datepicker({
+                format: 'yyyy-mm-dd',
+                calendarWeeks: true
+            })
+            .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('adds cw header column', function(){
+    var target = this.picker.find('.datepicker-days thead tr:nth-child(3) th:first-child');
+    ok(target.hasClass('cw'), 'First column heading is from cw column');
+});
+
+test('adds calendar week cells to each day row', function(){
+    var target = this.picker.find('.datepicker-days tbody tr');
+
+    expect(target.length);
+    target.each(function(i){
+        var t = $(this).children().first();
+        ok(t.hasClass('cw'), "First column is cw column");
+    });
+});
+
+test('displays correct calendar week', function(){
+    var target = this.picker.find('.datepicker-days tbody tr');
+
+    expect(target.length);
+    target.each(function(i){
+        var t = $(this).children().first();
+        equal(t.text(), i+1, "Displays correct calendar weeks");
+    });
+});
+
+test('it prepends column to switcher thead row', function(){
+    var target = this.picker.find('.datepicker-days thead tr:nth-child(2)');
+    equal(target.children().length, 3, 'first row has 3 columns');
+    ok(!target.children().first().hasClass('cw'), 'cw column is not prepended');
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/component.js b/public/bower_components/bootstrap-datepicker/tests/suites/component.js
new file mode 100644
index 0000000..7540b73
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/component.js
@@ -0,0 +1,267 @@
+module('Component', {
+    setup: function(){
+        this.component = $('<div class="input-append date" id="datepicker">'+
+                                '<input size="16" type="text" value="12-02-2012" readonly>'+
+                                '<span class="add-on"><i class="icon-th"></i></span>'+
+                            '</div>')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"});
+        this.input = this.component.find('input');
+        this.addon = this.component.find('.add-on');
+        this.dp = this.component.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+
+test('Component gets date/viewDate from input value', function(){
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 12));
+});
+
+test('Activation by component', function(){
+    ok(!this.picker.is(':visible'));
+    this.addon.click();
+    ok(this.picker.is(':visible'));
+});
+
+test('Dont activation (by disabled) by component', function(){
+    ok(!this.picker.is(':visible'));
+    this.input.prop('disabled', true);
+    this.addon.click();
+    ok(!this.picker.is(':visible'));
+    this.input.prop('disabled', false);
+});
+
+test('simple keyboard nav test', function(){
+    var target;
+
+    // Keyboard nav only works with non-readonly inputs
+    this.input.removeAttr('readonly');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 12));
+
+    // Focus/open
+    this.addon.click();
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 11));
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 11));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 month, shift + right arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39,
+        shiftKey: true
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 11));
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 11));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 11));
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 11));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+});
+
+test('setValue', function(){
+    this.dp.dates.replace(UTCDate(2012, 2, 13));
+    this.dp.setValue();
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+    equal(this.input.val(), '13-03-2012');
+});
+
+test('update', function(){
+    this.input.val('13-03-2012');
+    this.dp.update();
+    equal(this.dp.dates.length, 1);
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+});
+
+test('Navigating to/from decade view', function(){
+    var target;
+
+    this.addon.click();
+    this.input.val('31-03-2012');
+    this.dp.update();
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+
+    // Change years to test internal state changes
+    target = this.picker.find('.datepicker-years tbody span:contains(2011)');
+    target.click();
+    equal(this.dp.viewMode, 1);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 3, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+});
+
+test('Selecting date resets viewDate and date', function(){
+    var target;
+
+    this.addon.click();
+    this.input.val('31-03-2012');
+    this.dp.update();
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Feb 26
+
+    // Updated internally on click
+    target.click();
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 26));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 1, 26));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Jan 29
+});
+
+test('"destroy" removes associated HTML', function(){
+    var datepickerDivSelector = '.datepicker';
+
+    $('#datepicker').datepicker('show');
+
+    //there should be one datepicker initiated so that means one hidden .datepicker div
+    equal($(datepickerDivSelector).length, 1);
+    this.component.datepicker('destroy');
+    equal($(datepickerDivSelector).length, 0);//hidden HTML should be gone
+});
+
+test('"remove" is an alias for "destroy"', function(){
+    var called, originalDestroy = this.dp.destroy;
+    this.dp.destroy = function () {
+        called = true;
+        return originalDestroy.apply(this, arguments);
+    };
+    this.dp.remove();
+    ok(called);
+});
+
+test('Does not block events', function(){
+    var clicks = 0;
+    function handler(){
+        clicks++;
+    }
+    $('#qunit-fixture').on('click', '.add-on', handler);
+    this.addon.click();
+    equal(clicks, 1);
+    $('#qunit-fixture').off('click', '.add-on', handler);
+});
+
+
+test('date and viewDate must be between startDate and endDate when setStartDate called', function() {
+    this.dp.setDate(new Date(2013, 1, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2013, 1, 1));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 1, 1));
+    this.dp.setStartDate(new Date(2013, 5, 6));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 5, 6));
+    equal(this.dp.dates.length, 0);
+});
+
+test('date and viewDate must be between startDate and endDate when setEndDate called', function() {
+    this.dp.setDate(new Date(2013, 11, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2013, 11, 1));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 11, 1));
+    this.dp.setEndDate(new Date(2013, 5, 6));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 5, 6));
+    equal(this.dp.dates.length, 0);
+});
+
+test('picker should render fine when `$.fn.show` and `$.fn.hide` are overridden', patch_show_hide(function () {
+    var viewModes = $.fn.datepicker.DPGlobal.viewModes,
+        minViewMode = this.dp.o.minViewMode,
+        maxViewMode = this.dp.o.maxViewMode,
+        childDivs = this.picker.children('div');
+
+    this.dp.setViewMode(minViewMode);
+
+    // Overwritten `$.fn.hide` method adds the `foo` class to its matched elements
+    var curDivShowing = childDivs.filter('.datepicker-' + viewModes[minViewMode].clsName);
+    ok(!curDivShowing.hasClass('foo'), 'Shown div does not have overridden `$.fn.hide` side-effects');
+
+    // Check that other classes do have `foo` class
+    var divNotShown;
+    for (var curViewMode = minViewMode + 1; curViewMode <= maxViewMode; curViewMode++) {
+        divNotShown = childDivs.filter('.datepicker-' + viewModes[curViewMode].clsName);
+        ok(divNotShown.hasClass('foo'), 'Other divs do have overridden `$.fn.hide` side-effects');
+    }
+}));
+
+test('Focused ceil for decade/century/millenium views', function(){
+    var input = $('<input />')
+      .appendTo('#qunit-fixture')
+      .datepicker({
+        startView: 2,
+        defaultViewDate: {
+          year: 2115
+        }
+      }),
+      dp = input.data('datepicker'),
+      picker = dp.picker,
+      target;
+
+    input.focus();
+
+    target = picker.find('.datepicker-years tbody .focused');
+    ok(target.text() === '2115', 'Year cell is focused');
+
+    picker.find('.datepicker-years thead th.datepicker-switch').click();
+    target = picker.find('.datepicker-decades tbody .focused');
+    ok(target.text() === '2110', 'Decade cell is focused');
+
+    picker.find('.datepicker-decades thead th.datepicker-switch').click();
+    target = picker.find('.datepicker-centuries tbody .focused');
+    ok(target.text() === '2100', 'Century cell is focused');
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/data-api.js b/public/bower_components/bootstrap-datepicker/tests/suites/data-api.js
new file mode 100644
index 0000000..a751f57
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/data-api.js
@@ -0,0 +1,114 @@
+module('DATA-API');
+
+test('DATA-API: data-provide="datepicker" on input; focus', function(){
+    var input = $('<input data-provide="datepicker" />')
+                .appendTo('#qunit-fixture');
+    input.focus();
+    ok(input.data('datepicker'), 'datepicker is initialized by "focus" event');
+});
+
+test('DATA-API: data-provide="datepicker" on input; click', function(){
+    var input = $('<input data-provide="datepicker" />')
+                .appendTo('#qunit-fixture');
+    input.click();
+    ok(input.data('datepicker'), 'datepicker is initialized by "focus" event');
+});
+
+test('DATA-API: data-provide="datepicker" on component', function(){
+    var html, comp;
+
+    html = '<div class="input-append date" data-provide="datepicker">'+
+                '<input><span class="add-on"><i class="icon-th"></i></span>'+
+            '</div>';
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input').focus();
+    ok(comp.data('datepicker'), 'append component initialized by "focus" event on input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input').click();
+    ok(comp.data('datepicker'), 'append component initialized by "click" event on input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('.add-on').focus();
+    ok(comp.data('datepicker'), 'append component initialized by "focus" event on add-on');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('.add-on').click();
+    ok(comp.data('datepicker'), 'append component initialized by "click" event on add-on');
+    comp.remove();
+
+
+    html = '<div class="input-prepend date" data-provide="datepicker">'+
+                '<span class="add-on"><i class="icon-th"></i></span><input>'+
+            '</div>';
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('input').focus();
+    ok(comp.data('datepicker'), 'prepend component initialized by "focus" event on input');
+    comp.remove();
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('input').click();
+    ok(comp.data('datepicker'), 'prepend component initialized by "click" event on input');
+    comp.remove();
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('.add-on').focus();
+    ok(comp.data('datepicker'), 'prepend component initialized by "focus" event on add-on');
+    comp.remove();
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('.add-on').click();
+    ok(comp.data('datepicker'), 'prepend component initialized by "click" event on add-on');
+    comp.remove();
+});
+
+test('DATA-API: data-provide="datepicker" on button', function(){
+    var html, comp;
+
+    html = '<button data-provide="datepicker">';
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.focus();
+    ok(comp.data('datepicker'), 'button initialized by "focus" event on input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.click();
+    ok(comp.data('datepicker'), 'button initialized by "click" event on input');
+    comp.remove();
+});
+
+test('DATA-API: data-provide="datepicker" on rangepicker', function(){
+    var html, comp;
+
+    html = '<div class="input-daterange" data-provide="datepicker">'+
+                '<input class="datepicker">'+
+                '<span class="add-on">to</span>'+
+                '<input class="datepicker">'+
+            '</div>';
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:first').focus();
+    ok(comp.data('datepicker'), 'range initialized by "focus" event on first input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:first').click();
+    ok(comp.data('datepicker'), 'range initialized by "click" event on first input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:last').focus();
+    ok(comp.data('datepicker'), 'range initialized by "focus" event on last input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:last').click();
+    ok(comp.data('datepicker'), 'range initialized by "click" event on last input');
+    comp.remove();
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/events.js b/public/bower_components/bootstrap-datepicker/tests/suites/events.js
new file mode 100644
index 0000000..b1d92d2
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/events.js
@@ -0,0 +1,507 @@
+module('Events on initialization', {
+    setup: function(){
+        this.input = $('<input type="text" value="31-03-2011">')
+            .appendTo('#qunit-fixture')
+    }
+});
+
+test('When initializing the datepicker, it should trigger no change or changeDate events', function(){
+    var triggered_change = 0,
+        triggered_changeDate = 0;
+
+    this.input.on({
+        change: function(){
+            triggered_change++;
+        },
+        changeDate: function(){
+            triggered_changeDate++;
+        }
+    });
+
+    this.input.datepicker({format: 'dd-mm-yyyy'});
+
+    equal(triggered_change, 0);
+    equal(triggered_changeDate, 0);
+});
+
+module('Events', {
+    setup: function(){
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Selecting a year from decade view triggers changeYear', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeYear', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+
+    // Change years to test internal state changes
+    target = this.picker.find('.datepicker-years tbody span:contains(2010)');
+    target.click();
+    equal(this.dp.viewMode, 1);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2010, 2, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+    equal(triggered, 1);
+});
+
+test('Navigating forward/backward from month view triggers changeYear', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeYear', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+
+    target = this.picker.find('.datepicker-months thead th.prev');
+    ok(target.is(':visible'), 'Prev switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(triggered, 1);
+
+    target = this.picker.find('.datepicker-months thead th.next');
+    ok(target.is(':visible'), 'Next switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(triggered, 2);
+});
+
+test('Selecting a month from year view triggers changeMonth', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 3, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+    equal(triggered, 1);
+});
+
+test('Navigating forward/backward from month view triggers changeMonth', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.prev');
+    ok(target.is(':visible'), 'Prev switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Day picker is visible');
+    equal(triggered, 1);
+
+    target = this.picker.find('.datepicker-days thead th.next');
+    ok(target.is(':visible'), 'Next switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Day picker is visible');
+    equal(triggered, 2);
+});
+
+test('format() returns a formatted date string', function(){
+    var target,
+        error, out;
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format();
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    target.click();
+
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 14));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 14));
+    equal(error, undefined);
+    equal(out, '14-03-2011');
+});
+
+test('format(altformat) returns a formatted date string', function(){
+    var target,
+        error, out;
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format('m/d/yy');
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    target.click();
+
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 14));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 14));
+    equal(error, undefined);
+    equal(out, '3/14/11');
+});
+
+test('format(ix) returns a formatted date string of the ix\'th date selected', function(){
+    var target,
+        error, out;
+
+    this.dp._process_options({multidate: true});
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format(2);
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    target = this.picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '6'); // Mar 6
+    target.click();
+
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    equal(target.text(), '14'); // Mar 16
+    target.click();
+
+    equal(this.dp.dates.length, 3);
+
+    equal(error, undefined);
+    equal(out, '14-03-2011');
+});
+
+test('format(ix, altformat) returns a formatted date string', function(){
+    var target,
+        error, out;
+
+    this.dp._process_options({multidate: true});
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format(2, 'm/d/yy');
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    target = this.picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '6'); // Mar 6
+    target.click();
+
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    equal(target.text(), '14'); // Mar 16
+    target.click();
+
+    equal(this.dp.dates.length, 3);
+
+    equal(error, undefined);
+    equal(out, '3/14/11');
+});
+
+test('Clear button: triggers change and changeDate events', function(){
+    this.input = $('<input type="text" value="31-03-2011">')
+                    .appendTo('#qunit-fixture')
+                    .datepicker({
+                        format: "dd-mm-yyyy",
+                        clearBtn: true
+                    })
+                    .focus(); // Activate for visibility checks
+    this.dp = this.input.data('datepicker');
+    this.picker = this.dp.picker;
+
+    var target,
+        triggered_change = 0,
+        triggered_changeDate = 0;
+
+    this.input.on({
+        changeDate: function(){
+            triggered_changeDate++;
+        },
+        change: function(){
+            triggered_change++;
+        }
+    });
+
+    this.input.focus();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(this.picker.find('.datepicker-days tfoot .clear').is(':visible'), 'Clear button visible');
+
+    target = this.picker.find('.datepicker-days tfoot .clear');
+    target.click();
+
+    equal(triggered_change, 1);
+    equal(triggered_changeDate, 1);
+});
+
+test('setDate: triggers change and changeDate events', function(){
+    this.input = $('<input type="text" value="31-03-2011">')
+                    .appendTo('#qunit-fixture')
+                    .datepicker({
+                        format: "dd-mm-yyyy"
+                    })
+                    .focus(); // Activate for visibility checks
+    this.dp = this.input.data('datepicker');
+    this.picker = this.dp.picker;
+
+    var target,
+        triggered_change = 0,
+        triggered_changeDate = 0;
+
+    this.input.on({
+        changeDate: function(){
+            triggered_changeDate++;
+        },
+        change: function(){
+            triggered_change++;
+        }
+    });
+
+    this.input.focus();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+
+    this.dp.setDate(new Date(2011, 2, 5));
+
+    equal(triggered_change, 1);
+    equal(triggered_changeDate, 1);
+});
+
+test('paste must update the date', function() {
+    var dateToPaste = '22-07-2015';
+    var evt = {
+        type: 'paste',
+        originalEvent: {
+            clipboardData: {
+                types: ['text/plain'],
+                getData: function() { return dateToPaste; }
+            },
+            preventDefault: function() { evt.originalEvent.isDefaultPrevented = true; },
+            isDefaultPrevented: false
+        }
+    };
+    this.input.trigger(evt);
+    datesEqual(this.dp.dates[0], UTCDate(2015, 6, 22));
+
+    ok(evt.originalEvent.isDefaultPrevented, 'prevented original event');
+});
+
+test('clicking outside datepicker triggers \'hide\' event', function(){
+    var $otherelement = $('<div />');
+    $('body').append($otherelement);
+
+    var isHideTriggered;
+    this.input.on('hide', function() { isHideTriggered = true; });
+
+    $otherelement.trigger('mousedown');
+
+    ok(isHideTriggered, '\'hide\' event is not triggered');
+
+    $otherelement.remove();
+});
+
+test('Selecting date from previous month triggers changeMonth', function() {
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:first');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggered, 1);
+});
+
+test('Selecting date from previous month in january triggers changeMonth/changeYear', function() {
+    var target,
+        triggeredM = 0,
+        triggeredY = 0;
+
+    this.input.val('01-01-2011');
+    this.dp.update();
+
+    this.input.on('changeMonth', function(){
+        triggeredM++;
+    });
+
+    this.input.on('changeYear', function(){
+        triggeredY++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:first');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggeredM, 1);
+    equal(triggeredY, 1);
+});
+
+test('Selecting date from next month triggers changeMonth', function() {
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:last');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggered, 1);
+});
+
+test('Selecting date from next month in december triggers changeMonth/changeYear', function() {
+    var target,
+        triggeredM = 0,
+        triggeredY = 0;
+
+    this.input.val('01-12-2011');
+    this.dp.update();
+
+    this.input.on('changeMonth', function(){
+        triggeredM++;
+    });
+
+    this.input.on('changeYear', function(){
+        triggeredY++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:last');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggeredM, 1);
+    equal(triggeredY, 1);
+});
+
+test('Changing view mode triggers changeViewMode', function () {
+  var viewMode = -1,
+    triggered = 0;
+
+  this.input.val('22-07-2016');
+  this.dp.update();
+
+  this.input.on('changeViewMode', function (e) {
+    viewMode = e.viewMode;
+    triggered++;
+  });
+
+  // change from days to months
+  this.picker.find('.datepicker-days .datepicker-switch').click();
+  equal(triggered, 1);
+  equal(viewMode, 1);
+
+  // change from months to years
+  this.picker.find('.datepicker-months .datepicker-switch').click();
+  equal(triggered, 2);
+  equal(viewMode, 2);
+
+  // change from years to decade
+  this.picker.find('.datepicker-years .datepicker-switch').click();
+  equal(triggered, 3);
+  equal(viewMode, 3);
+
+  // change from decades to centuries
+  this.picker.find('.datepicker-decades .datepicker-switch').click();
+  equal(triggered, 4);
+  equal(viewMode, 4);
+
+});
+
+test('Clicking inside content of date with custom beforeShowDay content works', function(){
+    this.input = $('<input type="text" value="31-03-2011">')
+                    .appendTo('#qunit-fixture')
+                    .datepicker({
+                        format: "dd-mm-yyyy",
+                        beforeShowDay: function (date) { return { content: '<div><div>' + date.getDate() + '</div></div>' }; }
+                    })
+                    .focus(); // Activate for visibility checks
+    this.dp = this.input.data('datepicker');
+    this.picker = this.dp.picker;
+
+    var target,
+        triggered = 0;
+
+    this.input.on('changeDate', function(){
+        triggered++;
+    });
+
+    // find deepest date
+    target = this.picker.find('.datepicker-days tbody td:first div div');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggered, 1);
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/formats.js b/public/bower_components/bootstrap-datepicker/tests/suites/formats.js
new file mode 100644
index 0000000..93fcb52
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/formats.js
@@ -0,0 +1,314 @@
+module('Formats', {
+    setup: function(){
+        this.input = $('<input type="text">').appendTo('#qunit-fixture');
+        this.date = UTCDate(2012, 2, 15, 0, 0, 0, 0); // March 15, 2012
+    },
+    teardown: function(){
+        this.input.data('datepicker').picker.remove();
+    }
+});
+
+test('d: Day of month, no leading zero.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-mm-d'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[2], '5');
+});
+
+test('dd: Day of month, leading zero.', function(){
+    this.input
+        .val('2012-03-5')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[2], '05');
+});
+
+test('D: Day of week, short.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-mm-dd-D'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[3], 'Mon');
+});
+
+test('DD: Day of week, long.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-mm-dd-DD'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[3], 'Monday');
+});
+
+test('m: Month, no leading zero.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-m-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], '3');
+});
+
+test('mm: Month, leading zero.', function(){
+    this.input
+        .val('2012-3-5')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], '03');
+});
+
+test('M: Month shortname.', function(){
+    this.input
+        .val('2012-Mar-05')
+        .datepicker({format: 'yyyy-M-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'Mar');
+});
+
+test('M: Month shortname case insensitive.', function(){
+    this.input
+        .val('2012-MAR-05')
+        .datepicker({format: 'yyyy-M-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'Mar');
+});
+
+test('MM: Month full name.', function(){
+    this.input
+        .val('2012-March-5')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'March');
+});
+
+test('M: Month fullname case insensitive.', function(){
+    this.input
+        .val('2012-MARCH-05')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'March');
+});
+
+test('yy: Year, two-digit.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[0], '12');
+});
+
+test('yyyy: Year, four-digit.', function(){
+    this.input
+        .val('2012-03-5')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[0], '2012');
+});
+
+test('dd-mm-yyyy: Regression: Prevent potential month overflow in small-to-large formats (Mar 31, 2012 -> Mar 01, 2012)', function(){
+    this.input
+        .val('31-03-2012')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '31-03-2012');
+});
+
+test('dd-mm-yyyy: Leap day', function(){
+    this.input
+        .val('29-02-2012')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '29-02-2012');
+});
+
+test('yyyy-mm-dd: Alternative format', function(){
+    this.input
+        .val('2012-02-12')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val(), '2012-02-12');
+});
+
+test('yyyy-MM-dd: Regression: Infinite loop when numbers used for month', function(){
+    this.input
+        .val('2012-02-12')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .datepicker('setValue');
+    equal(this.input.val(), '2012-February-12');
+});
+
+test('+1d: Tomorrow', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1d')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '16-03-2012');
+}));
+
+test('tomorrow (alias for +1d): Tomorrow', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('tomorrow')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '16-03-2012');
+}));
+
+test('-1d: Yesterday', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1d')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '14-03-2012');
+}));
+
+test('yesterday (alias for -1d): Yesterday', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('yesterday')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '14-03-2012');
+}));
+
+test('+1w: Next week', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1w')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '22-03-2012');
+}));
+
+test('-1w: Last week', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1w')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '08-03-2012');
+}));
+
+test('+1m: Next month', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1m')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-04-2012');
+}));
+
+test('-1m: Last month', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1m')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-02-2012');
+}));
+
+test('+1y: Next year', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1y')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-03-2013');
+}));
+
+test('-1y: Last year', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1y')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-03-2011');
+}));
+
+test('-1y +2m: Multiformat', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1y +2m')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-05-2011');
+}));
+
+test('Regression: End-of-month bug', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('29-02-2012')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '29-02-2012');
+}));
+
+test('Invalid formats are force-parsed into a valid date on tab', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('44-44-4444')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .focus();
+
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 9
+    });
+
+    equal(this.input.val(), '56-September-30');
+}));
+
+test('Trailing separators', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('29.02.2012.')
+        .datepicker({format: 'dd.mm.yyyy.'})
+        .datepicker('setValue');
+    equal(this.input.val(), '29.02.2012.');
+}));
+
+test('Assume nearby year - last century', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/91')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/1991');
+}));
+
+test('Assume nearby year - this century (- 1 year)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/01')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/2001');
+}));
+
+test('Assume nearby year - this century (+ 7 years)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/19')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/2019');
+}));
+
+test('Assume nearby year - this century (+ 13 years)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/23')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/1923');
+}));
+
+test('Assume nearby year - this century (+ 13 years, threshold = 30)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/23')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: 30})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/2023');
+}));
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/inline.js b/public/bower_components/bootstrap-datepicker/tests/suites/inline.js
new file mode 100644
index 0000000..e2b7e9c
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/inline.js
@@ -0,0 +1,28 @@
+module('Inline', {
+    setup: function(){
+        this.component = $('<div data-date="12-02-2012"></div>')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"});
+        this.dp = this.component.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+
+test('Picker gets date/viewDate from data-date attr', function(){
+    datesEqual(this.dp.dates[0], UTCDate(2012, 1, 12));
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 12));
+});
+
+
+test('Visible after init', function(){
+    ok(this.picker.is(':visible'));
+});
+
+test('update', function(){
+    this.dp.update('13-03-2012');
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2011.js b/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2011.js
new file mode 100644
index 0000000..a64353a
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2011.js
@@ -0,0 +1,228 @@
+module('Keyboard Navigation 2011', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2011.  Fun facts:
+
+            * March 1, 2011 was on a Tuesday
+            * March 31, 2011 was on a Thursday
+        */
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Regression: by week (up/down arrows); up from Mar 6, 2011 should go to Feb 27, 2011', function(){
+    var target;
+
+    this.input.val('06-03-2011').datepicker('update');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 6));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 6));
+    equal(this.dp.focusDate, null);
+
+    // Navigation: -1 week, up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 27));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 6));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 27));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by day (left/right arrows); left from Mar 1, 2011 should go to Feb 28, 2011', function(){
+    var target;
+
+    this.input.val('01-03-2011').datepicker('update');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 1));
+    equal(this.dp.focusDate, null);
+
+    // Navigation: -1 day left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 1));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 28));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by month (shift + left/right arrows); left from Mar 15, 2011 should go to Feb 15, 2011', function(){
+    var target;
+
+    this.input.val('15-03-2011').datepicker('update');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+    equal(this.dp.focusDate, null);
+
+    // Navigation: -1 month, shift + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        shiftKey: true
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 15));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 15));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by month with view mode = 1 (left/right arrow); left from March 15, 2011 should go to February 15, 2011', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 1,
+      startView: 1
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 1);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 37
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2011, 1, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2011, 1, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by month with view mode = 1 (up/down arrow); down from March 15, 2011 should go to July 15, 2010', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 1,
+      startView: 1
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 1);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 40
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2011, 6, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2011, 6, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'July 2011', 'Title is "July 2011"');
+});
+
+test('Regression: by year with view mode = 2 (left/right arrow); left from March 15, 2011 should go to March 15, 2010', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 2,
+      startView: 2
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 2);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 37
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2010, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2010, 2, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2010', 'Title is "March 2010"');
+});
+
+test('Regression: by year with view mode = 2 (up/down arrow); dows from March 15, 2011 should go to March 15, 2015', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 2,
+      startView: 2
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 2);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 40
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2015, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2015, 2, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2015', 'Title is "March 2015"');
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2012.js b/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2012.js
new file mode 100644
index 0000000..53dbb7d
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2012.js
@@ -0,0 +1,483 @@
+module('Keyboard Navigation 2012', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2012.  Fun facts:
+
+            * February 1, 2012 was on a Wednesday
+            * February 29, 2012 was on a Wednesday
+            * March 1, 2012 was on a Thursday
+            * March 31, 2012 was on a Saturday
+        */
+        this.input = $('<input type="text" value="31-03-2012">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+
+test('by day (right/left arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 30));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: +1 day, right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 1));
+    // Month changed: April 1 (this is not a joke!)
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by week (up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 week, up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 24));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 24));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: +1 week, down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 7));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 7));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by month, v1 (shift + left/right arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 month, shift + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful date ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 29));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 month, shift + right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 29));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by month, v2 (shift + up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 month, shift + up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful date ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 29));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 month, shift + down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 29));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by year, v1 (ctrl + left/right arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39,
+            ctrlKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, v2 (ctrl + up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40,
+            ctrlKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, v3 (ctrl + shift + left/right arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39,
+            ctrlKey: true,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, v4 (ctrl + shift + up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38,
+        ctrlKey: true,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40,
+            ctrlKey: true,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, from leap day', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+
+    this.input.val('29-02-2012').datepicker('update');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    equal(this.dp.focusDate, null);
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: -1 year
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful month ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 28));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+
+    // Navigation: +1 year, back to leap year
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful month ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 28));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 year
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful month ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2013, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 1, 28));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2013', 'Title is "February 2013"');
+});
+
+test('Selection (enter)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 30));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Selection: Enter
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 13
+    });
+    // view and selection updated, focus cleared
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 30));
+    equal(this.dp.focusDate, null);
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    ok(this.picker.is(':visible'), 'Picker is not hidden');
+});
+
+test('Selection + hide (enter)', function(){
+    var target;
+
+    this.dp._process_options({autoclose: true});
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 30));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Selection: Enter
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 13
+    });
+    // view and selection updatedfocus cleared
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 30));
+    equal(this.dp.focusDate, null);
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+});
+
+test('Toggle hide/show (escape); navigation while hidden is suppressed', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+
+    // Hide
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 27
+    });
+
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // left arrow key, *doesn't* navigate
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Show - with escape key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 27
+    });
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Hide
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 27
+    });
+
+    // Show - with down key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 40
+    });
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+});
+
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/all.js b/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/all.js
new file mode 100644
index 0000000..4fb6d2f
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/all.js
@@ -0,0 +1,62 @@
+module('Keyboard Navigation (All)', {
+    setup: function(){
+        this.input = $('<input type="text">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('TAB hides picker', function(){
+    var target;
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 9
+    });
+
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+});
+
+test('by day (right/left arrows) with daysOfWeekDisabled', function(){
+    var target;
+
+    this.input.val('04-03-2013');
+    this.dp.setDaysOfWeekDisabled('0,6');
+    this.dp.update();
+
+    this.input.focus();
+
+    // Navigation: -1 day left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 1));
+});
+
+test('by day (right/left arrows) with datesDisabled', function(){
+    var target;
+
+    this.input.val('04-03-2013');
+    this.dp.setDatesDisabled(['05-03-2013']);
+    this.dp.update();
+
+    this.input.focus();
+
+    // Navigation: +1 day right arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39
+    });
+
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 6));
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/methods.js b/public/bower_components/bootstrap-datepicker/tests/suites/methods.js
new file mode 100644
index 0000000..b70834f
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/methods.js
@@ -0,0 +1,188 @@
+module('Methods', {
+    setup: function(){
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"});
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.dp.remove();
+    }
+});
+
+test('remove', function(){
+    var returnedObject = this.dp.remove();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('show', function(){
+    var returnedObject = this.dp.show();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('hide', function(){
+    var returnedObject = this.dp.hide();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - String', function(){
+    var returnedObject = this.dp.update('13-03-2012');
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+    var date = this.dp.picker.find('.datepicker-days td:contains(13)');
+    ok(date.hasClass('active'), 'Date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - Date', function(){
+    var returnedObject = this.dp.update(new Date(2012, 2, 13));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+    var date = this.dp.picker.find('.datepicker-days td:contains(13)');
+    ok(date.hasClass('active'), 'Date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - Date with time', function(){
+    var returnedObject = this.dp.update(new Date(2012, 2, 13, 23, 59, 59, 999));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13, 23, 59, 59, 999));
+    var date = this.dp.picker.find('.datepicker-days td:contains(13)');
+    ok(date.hasClass('active'), 'Date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - null', function(){
+    var returnedObject = this.dp.update(null);
+    equal(this.dp.dates[0], undefined);
+    var selected = this.dp.picker.find('.datepicker-days td.active');
+    equal(selected.length, 0, 'No date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDate', function(){
+    var date_in = new Date(2013, 1, 1),
+        expected_date = new Date(Date.UTC(2013, 1, 1)),
+        returnedObject;
+
+    notEqual(this.dp.dates[0], date_in);
+    returnedObject = this.dp.setDate(date_in);
+    strictEqual(returnedObject, this.dp, "is chainable");
+    datesEqual(this.dp.dates[0], expected_date);
+});
+
+test('setUTCDate', function(){
+    var date_in = new Date(Date.UTC(2012, 3, 5)),
+        expected_date = date_in,
+        returnedObject;
+
+    notEqual(this.dp.dates[0], date_in);
+    returnedObject = this.dp.setUTCDate(date_in);
+    strictEqual(returnedObject, this.dp, "is chainable");
+    datesEqual(this.dp.dates[0], expected_date);
+});
+
+test('setStartDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setStartDate(date_in);
+    // ...
+    datesEqual(this.dp.o.startDate, expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setEndDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setEndDate(date_in);
+    // ...
+    datesEqual(this.dp.o.endDate, expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('getStartDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setStartDate(date_in);
+    // ...
+    datesEqual(returnedObject.getStartDate(), expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('getEndDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setEndDate(date_in);
+    // ...
+    datesEqual(returnedObject.getEndDate(), expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDaysOfWeekDisabled - String', function(){
+    var days_in = "0,6",
+        expected_days = [0,6],
+        returnedObject = this.dp.setDaysOfWeekDisabled(days_in);
+    // ...
+    deepEqual(this.dp.o.daysOfWeekDisabled, expected_days);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDaysOfWeekDisabled - Array', function(){
+    var days_in = [0,6],
+        expected_days = days_in,
+        returnedObject = this.dp.setDaysOfWeekDisabled(days_in);
+    // ...
+    deepEqual(this.dp.o.daysOfWeekDisabled, expected_days);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDatesDisabled', function(){
+    var monthShown = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    var returnedObject = this.dp.setDatesDisabled(['01-03-2011']);
+    ok(this.picker.find('.datepicker-days tbody td.day:not(.old):first').hasClass('disabled'), 'day is disabled');
+    this.dp.setDatesDisabled(['01-01-2011']);
+    equal(monthShown.text(), 'March 2011', 'should not change viewDate');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setValue', function(){
+    var returnedObject = this.dp.setValue();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('place', function(){
+    var returnedObject = this.dp.place();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('moveMonth - can handle invalid date', function(){
+    // any input which results in an invalid date, f.e. an incorrectly formatted.
+    var invalidDate = new Date("invalid"),
+        returnedObject = this.dp.moveMonth(invalidDate, 1);
+    // ...
+    equal(this.input.val(), "31-03-2011", "date is reset");
+});
+
+test('parseDate - outputs correct value', function(){
+    var parsedDate = $.fn.datepicker.DPGlobal.parseDate('11/13/2015', $.fn.datepicker.DPGlobal.parseFormat('mm/dd/yyyy'), 'en');
+    equal(parsedDate.getUTCDate(), "13", "date is correct");
+    equal(parsedDate.getUTCMonth(), "10", "month is correct");
+    equal(parsedDate.getUTCFullYear(), "2015", "fullyear is correct");
+});
+
+test('parseDate - outputs correct value for yyyy\u5E74mm\u6708dd\u65E5 format', function(){
+    var parsedDate = $.fn.datepicker.DPGlobal.parseDate('2015\u5E7411\u670813', $.fn.datepicker.DPGlobal.parseFormat('yyyy\u5E74mm\u6708dd\u65E5'), 'ja');
+    equal(parsedDate.getUTCDate(), "13", "date is correct");
+    equal(parsedDate.getUTCMonth(), "10", "month is correct");
+    equal(parsedDate.getUTCFullYear(), "2015", "fullyear is correct");
+});
+
+test('parseDate - outputs correct value for dates containing unicodes', function(){
+    var parsedDate = $.fn.datepicker.DPGlobal.parseDate('\u5341\u4E00\u6708 13 2015', $.fn.datepicker.DPGlobal.parseFormat('MM dd yyyy'), 'zh-CN');
+    equal(parsedDate.getUTCDate(), "13", "date is correct");
+    equal(parsedDate.getUTCMonth(), "10", "month is correct");
+    equal(parsedDate.getUTCFullYear(), "2015", "fullyear is correct");
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/methods_jquery.js b/public/bower_components/bootstrap-datepicker/tests/suites/methods_jquery.js
new file mode 100644
index 0000000..e934d49
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/methods_jquery.js
@@ -0,0 +1,26 @@
+module('Methods (jQuery)', {
+    setup: function(){
+        this.$inputs = $('<input><input>')
+            .datepicker()
+            .appendTo('#qunit-fixture');
+    },
+    teardown: function(){
+        this.$inputs.each(function(){
+            $.data(this, 'datepicker').picker.remove();
+        });
+    }
+});
+
+test('Methods', function(){
+    [
+        'show',
+        'hide',
+        'setValue',
+        'place'
+    ].forEach($.proxy(function(index, value){
+        var returnedObject = this.$inputs.datepicker(value);
+
+        strictEqual(returnedObject, this.$inputs, "is jQuery element");
+        strictEqual(returnedObject.length, 2, "correct length of jQuery elements");
+    }, this));
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2011.js b/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2011.js
new file mode 100644
index 0000000..9aa4628
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2011.js
@@ -0,0 +1,66 @@
+module('Mouse Navigation 2011', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2011.
+        */
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Selecting date from previous month while in January changes month and year displayed', function(){
+    var target;
+
+    this.input.val('01-01-2011');
+    this.dp.update();
+    datesEqual(this.dp.viewDate, UTCDate(2011, 0, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 0, 1));
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Dec 26
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'January 2011');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'December 2010');
+    datesEqual(this.dp.viewDate, UTCDate(2010, 11, 26));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2010, 11, 26));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '28'); // Should be Nov 28
+});
+
+test('Selecting date from next month while in December changes month and year displayed', function(){
+    var target;
+
+    this.input.val('01-12-2010');
+    this.dp.update();
+    datesEqual(this.dp.viewDate, UTCDate(2010, 11, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2010, 11, 1));
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:last');
+    equal(target.text(), '8'); // Should be Jan 8
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'December 2010');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'January 2011');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 0, 8));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 0, 8));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Dec 26
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2012.js b/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2012.js
new file mode 100644
index 0000000..071df9b
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2012.js
@@ -0,0 +1,266 @@
+module('Mouse Navigation 2012', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2012.  Fun facts:
+
+            * February 1, 2012 was on a Wednesday
+            * February 29, 2012 was on a Wednesday
+            * March 1, 2012 was on a Thursday
+            * March 31, 2012 was on a Saturday
+        */
+        this.input = $('<input type="text" value="31-03-2012">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Selecting date resets viewDate and date', function(){
+    var target;
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '4'); // Should be Mar 4
+
+    // Updated internally on click
+    target.click();
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 4));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 4));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Feb 29
+});
+
+test('Navigating next/prev by month', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.prev');
+    ok(target.is(':visible'), 'Month:prev nav is visible');
+
+    // Updated internally on click
+    target.click();
+    // Should handle month-length changes gracefully
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Jan 29
+
+    target = this.picker.find('.datepicker-days thead th.next');
+    ok(target.is(':visible'), 'Month:next nav is visible');
+
+    // Updated internally on click
+    target.click().click();
+    // Graceful moonth-end handling carries over
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '25'); // Should be Mar 25
+    // (includes "old" days at start of month, even if that's all the first week-row consists of)
+});
+
+test('Navigating to/from year view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Change months to test internal state
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 1)); // Apr 30
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Navigating to/from decade view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Change years to test internal state changes
+    target = this.picker.find('.datepicker-years tbody span:contains(2011)');
+    target.click();
+    equal(this.dp.viewMode, 1);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 3, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Navigating prev/next in year view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    equal(this.picker.find('.datepicker-months thead th.datepicker-switch').text(), '2012');
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to next year (2013)
+    target = this.picker.find('.datepicker-months thead th.next');
+    target.click();
+    equal(this.picker.find('.datepicker-months thead th.datepicker-switch').text(), '2013');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to prev year (x2 == 2011)
+    target = this.picker.find('.datepicker-months thead th.prev');
+    target.click().click();
+    equal(this.picker.find('.datepicker-months thead th.datepicker-switch').text(), '2011');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Navigating prev/next in decade view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    equal(this.picker.find('.datepicker-years thead th.datepicker-switch').text(), '2010-2019');
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to next decade (2020-29)
+    target = this.picker.find('.datepicker-years thead th.next');
+    target.click();
+    equal(this.picker.find('.datepicker-years thead th.datepicker-switch').text(), '2020-2029');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2022, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to prev year (x2 == 2000-09)
+    target = this.picker.find('.datepicker-years thead th.prev');
+    target.click().click();
+    equal(this.picker.find('.datepicker-years thead th.datepicker-switch').text(), '2000-2009');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2002, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Selecting date from previous month resets viewDate and date, changing month displayed', function(){
+    var target;
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Feb 26
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'March 2012');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'February 2012');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 26));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 26));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Jan 29
+});
+
+test('Selecting date from next month resets viewDate and date, changing month displayed', function(){
+    var target;
+
+    this.input.val('01-04-2012');
+    this.dp.update();
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:last');
+    equal(target.text(), '5'); // Should be May 5
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'April 2012');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'May 2012');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 4, 5));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 4, 5));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Apr 29
+});
+
+test('Selecting today from next month', patch_date(function(Date){
+    var target;
+    this.dp.o.todayHighlight = true;
+    Date.now = new Date(2012, 2, 3); // Mar 3
+    this.input.val('01-02-2012');    // Feb 1
+    this.dp.update();
+
+    // Click the today button
+    target = this.picker.find('.datepicker-days tbody td.today');
+    equal(target.text(), '3'); // Should be Mar 3
+    target.click();
+
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 3));
+}));
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/all.js b/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/all.js
new file mode 100644
index 0000000..5f1436e
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/all.js
@@ -0,0 +1,33 @@
+module('Mouse Navigation (All)', {
+    setup: function(){
+        this.input = $('<input type="text">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Clicking datepicker does not hide datepicker', function(){
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    this.picker.trigger('mousedown');
+    ok(this.picker.is(':visible'), 'Picker is still visible');
+});
+
+test('Clicking outside datepicker hides datepicker', function(){
+    var $otherelement = $('<div />');
+    $('body').append($otherelement);
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    this.input.trigger('click');
+    ok(this.picker.is(':visible'), 'Picker is still visible');
+
+    $otherelement.trigger('mousedown');
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+
+    $otherelement.remove();
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/noconflict.js b/public/bower_components/bootstrap-datepicker/tests/suites/noconflict.js
new file mode 100644
index 0000000..58bff1a
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/noconflict.js
@@ -0,0 +1,20 @@
+module('NoConflict', {
+    setup: function(){
+        var datepicker = $.fn.datepicker.noConflict();
+        $.fn.bootstrapDP = datepicker;
+    },
+    teardown: function(){
+        $.fn.datepicker = $.fn.bootstrapDP;
+        delete $.fn.bootstrapDP;
+    }
+});
+
+test('Datepicker starts after calling noConflict() (no undefined defaults or locale_opts)', function(){
+    $('<div class="input-append date" id="datepicker">'+
+        '<input size="16" type="text" value="12-02-2012" readonly>'+
+        '<span class="add-on"><i class="icon-th"></i></span>'+
+        '</div>')
+        .appendTo('#qunit-fixture')
+        .bootstrapDP();
+    expect(0);
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/options.js b/public/bower_components/bootstrap-datepicker/tests/suites/options.js
new file mode 100644
index 0000000..5a22c9f
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/options.js
@@ -0,0 +1,1802 @@
+module('Options', {
+    setup: function(){},
+    teardown: function(){
+        $('#qunit-fixture *').each(function(){
+            var t = $(this);
+            if ('datepicker' in t.data())
+                t.datepicker('remove');
+        });
+    }
+});
+
+test('Autoclose', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    autoclose: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+
+    input.focus();
+    ok(picker.is(':visible'), 'Picker is visible');
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '4'); // Mar 4
+
+    target.click();
+    ok(picker.is(':not(:visible)'), 'Picker is hidden');
+    datesEqual(dp.dates[0], UTCDate(2012, 2, 4));
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+});
+
+test('Custom date formatter functions', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2015-09-18T00:00:00.000Z')
+                .datepicker({
+                    format: {
+                        /*
+                        Say our UI should display a week ahead,
+                        but textbox should store the actual date.
+                        This is useful if we need UI to select local dates,
+                        but store in UTC
+                        */
+                        toDisplay: function (date, format, language) {
+                            var d = new Date(date);
+                            d.setDate(d.getDate() - 7);
+                            return d.toISOString();
+                        },
+                        toValue: function (date, format, language) {
+                            var d = new Date(date);
+                            d.setDate(d.getDate() + 7);
+                            return new Date(d);
+                        }
+                    },
+                    autoclose: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+    //Value is ISO format and is 7 days older than UI
+    equal(input.val(), '2015-09-18T00:00:00.000Z');
+    datesEqual(dp.dates[0], UTCDate(2015, 8, 25));
+    datesEqual(dp.viewDate, UTCDate(2015, 8, 25));
+
+    input.focus();
+    ok(picker.is(':visible'), 'Picker is visible');
+    target = picker.find('.datepicker-days tbody td:nth(5)');
+    equal(target.text(), '4'); // Sep 4
+
+    target.click();
+    ok(picker.is(':not(:visible)'), 'Picker is hidden');
+    //Value is now 28th Aug 2015 in ISO format
+    //and is 7 days older than UI
+    equal(input.val(), '2015-08-28T00:00:00.000Z');
+    datesEqual(dp.dates[0], UTCDate(2015, 8, 4));
+    datesEqual(dp.viewDate, UTCDate(2015, 8, 4));
+});
+
+test('Startview: year view (integer)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 1
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':visible'), 'Months view visible');
+    ok(picker.find('.datepicker-years').is(':not(:visible)'), 'Years view hidden');
+    ok(picker.find('.datepicker-decades').is(':not(:visible)'), 'Decades view hidden');
+    ok(picker.find('.datepicker-centuries').is(':not(:visible)'), 'Centuries view hidden');
+});
+
+test('Startview: year view (string)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 'year'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':visible'), 'Months view visible');
+    ok(picker.find('.datepicker-years').is(':not(:visible)'), 'Years view hidden');
+    ok(picker.find('.datepicker-decades').is(':not(:visible)'), 'Decades view hidden');
+    ok(picker.find('.datepicker-centuries').is(':not(:visible)'), 'Centuries view hidden');
+});
+
+test('Startview: decade view (integer)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 2
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':visible'), 'Years view visible');
+    ok(picker.find('.datepicker-decades').is(':not(:visible)'), 'Decades view hidden');
+    ok(picker.find('.datepicker-centuries').is(':not(:visible)'), 'Centuries view hidden');
+});
+
+test('Startview: decade view (string)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 'decade'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':visible'), 'Years view visible');
+    ok(picker.find('.datepicker-decades').is(':not(:visible)'), 'Decades view hidden');
+    ok(picker.find('.datepicker-centuries').is(':not(:visible)'), 'Centuries view hidden');
+});
+
+test('Startview: century view (integer)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 3
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':not(:visible)'), 'Years view hidden');
+    ok(picker.find('.datepicker-decades').is(':visible'), 'Decades view visible');
+    ok(picker.find('.datepicker-centuries').is(':not(:visible)'), 'Centuries view hidden');
+});
+
+test('Startview: century view (string)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 'century'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':not(:visible)'), 'Years view hidden');
+    ok(picker.find('.datepicker-decades').is(':visible'), 'Decades view visible');
+    ok(picker.find('.datepicker-centuries').is(':not(:visible)'), 'Centuries view hidden');
+});
+
+test('Startview: millennium view (integer)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 4
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':not(:visible)'), 'Years view hidden');
+    ok(picker.find('.datepicker-decades').is(':not(:visible)'), 'Decades view hidden');
+    ok(picker.find('.datepicker-centuries').is(':visible'), 'Centuries view visible');
+});
+
+test('Startview: millennium view (string)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: 'millennium'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':not(:visible)'), 'Years view hidden');
+    ok(picker.find('.datepicker-decades').is(':not(:visible)'), 'Decades view hidden');
+    ok(picker.find('.datepicker-centuries').is(':visible'), 'Centuries view visible');
+});
+
+test('Today Button: today button not default', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .today').is(':not(:visible)'), 'Today button not visible');
+});
+
+test('Today Button: today visibility when enabled', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    todayBtn: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .today').is(':visible'), 'Today button visible');
+
+    picker.find('.datepicker-days thead th.datepicker-switch').click();
+    ok(picker.find('.datepicker-months').is(':visible'), 'Months view visible');
+    ok(picker.find('.datepicker-months tfoot .today').is(':visible'), 'Today button visible');
+
+    picker.find('.datepicker-months thead th.datepicker-switch').click();
+    ok(picker.find('.datepicker-years').is(':visible'), 'Years view visible');
+    ok(picker.find('.datepicker-years tfoot .today').is(':visible'), 'Today button visible');
+});
+
+test('Today Button: data-api', function(){
+    var input = $('<input data-date-today-btn="true" />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .today').is(':visible'), 'Today button visible');
+});
+
+test('Today Button: moves to today\'s date', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    todayBtn: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .today').is(':visible'), 'Today button visible');
+
+    target = picker.find('.datepicker-days tfoot .today');
+    target.click();
+
+    var d = new Date(),
+        today = UTCDate(d.getFullYear(), d.getMonth(), d.getDate());
+    datesEqual(dp.viewDate, today);
+    datesEqual(dp.dates[0], UTCDate(2012, 2, 5));
+});
+
+test('Today Button: moves to days view', function(){
+    var viewModes = $.fn.datepicker.DPGlobal.viewModes;
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startView: viewModes.length - 1,
+                    todayBtn: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('tfoot .today').filter(':visible');
+
+    target.click();
+    ok(picker.find('.datepicker-days tfoot .today').is(':visible'), 'Today button visible');
+});
+
+test('Today Button: "linked" selects today\'s date', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    todayBtn: "linked"
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .today').is(':visible'), 'Today button visible');
+
+    target = picker.find('.datepicker-days tfoot .today');
+    target.click();
+
+    var d = new Date(),
+        today = UTCDate(d.getFullYear(), d.getMonth(), d.getDate());
+    datesEqual(dp.viewDate, today);
+    datesEqual(dp.dates[0], today);
+});
+
+test('Today Highlight: today\'s date is not highlighted by default', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    equal(picker.find('.datepicker-days thead .datepicker-switch').text(), 'March 2012', 'Title is "March 2012"');
+
+    target = picker.find('.datepicker-days tbody td:contains(15)');
+    ok(!target.hasClass('today'), 'Today is not marked with "today" class');
+    target = picker.find('.datepicker-days tbody td:contains(14)');
+    ok(!target.hasClass('today'), 'Yesterday is not marked with "today" class');
+    target = picker.find('.datepicker-days tbody td:contains(16)');
+    ok(!target.hasClass('today'), 'Tomorrow is not marked with "today" class');
+}));
+
+test('Today Highlight: today\'s date is highlighted when not active', patch_date(function(Date){
+    Date.now = new Date(2012, 2, 15);
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    todayHighlight: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    equal(picker.find('.datepicker-days thead .datepicker-switch').text(), 'March 2012', 'Title is "March 2012"');
+
+    target = picker.find('.datepicker-days tbody td:contains(15)');
+    ok(target.hasClass('today'), 'Today is marked with "today" class');
+    target = picker.find('.datepicker-days tbody td:contains(14)');
+    ok(!target.hasClass('today'), 'Yesterday is not marked with "today" class');
+    target = picker.find('.datepicker-days tbody td:contains(16)');
+    ok(!target.hasClass('today'), 'Tomorrow is not marked with "today" class');
+}));
+
+test('Clear Button: clear visibility when enabled', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    clearBtn: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .clear').is(':visible'), 'Clear button visible');
+
+    picker.find('.datepicker-days thead th.datepicker-switch').click();
+    ok(picker.find('.datepicker-months').is(':visible'), 'Months view visible');
+    ok(picker.find('.datepicker-months tfoot .clear').is(':visible'), 'Clear button visible');
+
+    picker.find('.datepicker-months thead th.datepicker-switch').click();
+    ok(picker.find('.datepicker-years').is(':visible'), 'Years view visible');
+    ok(picker.find('.datepicker-years tfoot .clear').is(':visible'), 'Clear button visible');
+});
+
+test('Clear Button: clears input value', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    clearBtn: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .clear').is(':visible'), 'Today button visible');
+
+    target = picker.find('.datepicker-days tfoot .clear');
+    target.click();
+
+    equal(input.val(),'',"Input value has been cleared.");
+    ok(picker.is(':visible'), 'Picker is visible');
+});
+
+test('Clear Button: hides datepicker if autoclose is on', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    clearBtn: true,
+                    autoclose: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(picker.find('.datepicker-days tfoot .clear').is(':visible'), 'Today button visible');
+
+    target = picker.find('.datepicker-days tfoot .clear');
+    target.click();
+
+    equal(input.val(),'',"Input value has been cleared.");
+    ok(picker.is(':not(:visible)'), 'Picker is hidden');
+});
+
+test('Active Toggle Default: when active date is selected it is not unset', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    // open our datepicker
+    input.focus();
+
+    // Initial value is selected
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 selected');
+
+    // click on our active date
+    target = picker.find('.datepicker-days .day.active');
+    target.click();
+
+    // make sure it's still set
+    equal(input.val(), '2012-03-05', "Input value has not been cleared.");
+});
+
+test('Active Toggle Enabled (single date): when active date is selected it is unset', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    toggleActive: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    // open our datepicker
+    input.focus();
+
+    // Initial value is selected
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 selected');
+
+    // click on our active date
+    target = picker.find('.datepicker-days .day.active');
+    target.click();
+
+    // make sure it's no longer set
+    equal(input.val(), '', "Input value has been cleared.");
+});
+
+test('Active Toggle Multidate Default: when one of the active dates is selected it is unset', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    multidate: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    // open our datepicker
+    input.focus();
+
+    // Initial value is selected
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 in dates');
+
+    // Select additional date
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    target.click();
+    datesEqual(dp.dates.get(-1), UTCDate(2012, 2, 4), '2012-03-04 in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+    equal(input.val(), '2012-03-05,2012-03-04');
+
+    // Unselect additional date
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    target.click();
+    ok(dp.dates.contains(UTCDate(2012, 2, 4)) === -1, '2012-03-04 no longer in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+    equal(input.val(), '2012-03-05');
+});
+
+test('Active Toggle Disabled: when active date is selected it remains', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    toggleActive: false
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    // open our datepicker
+    input.focus();
+
+    // Initial value is selected
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 selected');
+
+    // click on our active date
+    target = picker.find('.datepicker-days .day.active');
+    target.click();
+
+    // make sure it's still set
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 still selected');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 5));
+    equal(input.val(), '2012-03-05');
+});
+
+test('Active Toggle Multidate Disabled: when activeToggle is set to false, but multidate is set, the option is ignored and selecting an active date it is unset', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    multidate: true,
+                    toggleActive: false
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    // open our datepicker
+    input.focus();
+
+    // Initial value is selected
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 in dates');
+
+    // Select additional date
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    target.click();
+    datesEqual(dp.dates.get(-1), UTCDate(2012, 2, 4), '2012-03-04 in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+    equal(input.val(), '2012-03-05,2012-03-04');
+
+    // Unselect additional date
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    target.click();
+    ok(dp.dates.contains(UTCDate(2012, 2, 4)) === -1, '2012-03-04 no longer in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+    equal(input.val(), '2012-03-05');
+});
+
+test('DaysOfWeekDisabled', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    daysOfWeekDisabled: '1,5'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(22)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(24)');
+    ok(!target.hasClass('disabled'), 'Day of week is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(26)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+});
+
+test('DaysOfWeekHighlighted', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startDate: '2012-10-02',
+                    daysOfWeekHighlighted: '1,5'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(0)');
+    ok(!target.hasClass('highlighted'), 'Day of week is not highlighted');
+    target = picker.find('.datepicker-days tbody td:nth(22)');
+    ok(target.hasClass('highlighted'), 'Day of week is highlighted');
+    target = picker.find('.datepicker-days tbody td:nth(24)');
+    ok(!target.hasClass('highlighted'), 'Day of week is not highlighted');
+    target = picker.find('.datepicker-days tbody td:nth(26)');
+    ok(target.hasClass('highlighted'), 'Day of week is highlighted');
+});
+
+test('DatesDisabled', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    datesDisabled: ['2012-10-1', '2012-10-10', '2012-10-20']
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(1)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+    ok(target.hasClass('disabled-date'), 'Date is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(2)');
+    ok(!target.hasClass('disabled'), 'Day of week is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(10)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+    ok(target.hasClass('disabled-date'), 'Date is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(11)');
+    ok(!target.hasClass('disabled'), 'Day of week is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(20)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+    ok(target.hasClass('disabled-date'), 'Date is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(21)');
+    ok(!target.hasClass('disabled'), 'Day of week is enabled');
+});
+
+test('DatesDisabled as attribute', function(){
+    var input = $('<input data-date-dates-disabled="2012-10-1,2012-10-10,2012-10-20" />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(1)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+    ok(target.hasClass('disabled-date'), 'Date is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(2)');
+    ok(!target.hasClass('disabled'), 'Day of week is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(10)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+    ok(target.hasClass('disabled-date'), 'Date is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(11)');
+    ok(!target.hasClass('disabled'), 'Day of week is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(20)');
+    ok(target.hasClass('disabled'), 'Day of week is disabled');
+    ok(target.hasClass('disabled-date'), 'Date is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(21)');
+    ok(!target.hasClass('disabled'), 'Day of week is enabled');
+});
+
+test('BeforeShowDay', function(){
+
+    var beforeShowDay = function(date) {
+        switch (date.getDate()){
+            case 25:
+                return {
+                    tooltip: 'Example tooltip',
+                    classes: 'active'
+                };
+            case 26:
+                return "test26";
+            case 27:
+                return {enabled: false, classes: 'test27'};
+            case 28:
+                return false;
+            case 30:
+                return { content: "foo" + date.getDate() }
+        }
+    };
+
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    beforeShowDay: beforeShowDay
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(25)');
+    equal(target.attr('title'), 'Example tooltip', '25th has tooltip');
+    ok(!target.hasClass('disabled'), '25th is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(26)');
+    ok(target.hasClass('test26'), '26th has test26 class');
+    ok(!target.hasClass('disabled'), '26th is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(27)');
+    ok(target.hasClass('test27'), '27th has test27 class');
+    ok(target.hasClass('disabled'), '27th is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(28)');
+    ok(target.hasClass('disabled'), '28th is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(29)');
+    ok(!target.hasClass('disabled'), '29th is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(30)');
+    ok(target.text() == "foo30", '30th has custom content');
+});
+
+test('BeforeShowMonth regress .day content', function() {
+    var input = $('<input />')
+        .appendTo('#qunit-fixture')
+        .val('2012-10-26')
+        .datepicker({
+            format: 'yyyy-mm-dd',
+            beforeShowDay: function(date) {
+                return {
+                    content: '<strong>foo123</strong>'
+                };
+            }
+        }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(30)');
+    target.trigger('click');
+    datesEqual(dp.viewDate, UTCDate(2012, 9, 30));
+});
+
+test('BeforeShowMonth', function () {
+
+    var beforeShowMonth = function (date) {
+        switch (date.getMonth()) {
+            case 0:
+                return {
+                    tooltip: 'Example tooltip',
+                    classes: 'active'
+                };
+            case 2:
+                return "testMarch";
+            case 4:
+                return {enabled: false, classes: 'testMay'};
+            case 5:
+                return false;
+        }
+    };
+
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('2012-10-26')
+            .datepicker({
+                format: 'yyyy-mm-dd',
+                beforeShowMonth: beforeShowMonth
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-months tbody span:nth(0)');
+    equal(target.attr('title'), 'Example tooltip', '1st has tooltip');
+    ok(!target.hasClass('disabled'), 'January is enabled');
+    target = picker.find('.datepicker-months tbody span:nth(2)');
+    ok(target.hasClass('testMarch'), 'March has testMarch class');
+    ok(!target.hasClass('disabled'), 'March enabled');
+    target = picker.find('.datepicker-months tbody span:nth(4)');
+    ok(target.hasClass('testMay'), 'May has testMay class');
+    ok(target.hasClass('disabled'), 'May is disabled');
+    target = picker.find('.datepicker-months tbody span:nth(5)');
+    ok(target.hasClass('disabled'), 'June is disabled');
+    target = picker.find('.datepicker-months tbody span:nth(6)');
+    ok(!target.hasClass('disabled'), 'July is enabled');
+});
+
+
+test('BeforeShowYear', function () {
+
+    var beforeShowYear = function (date) {
+        switch (date.getFullYear()) {
+            case 2013:
+                return {
+                    tooltip: 'Example tooltip',
+                    classes: 'active'
+                };
+            case 2014:
+                return "test2014";
+            case 2015:
+                return {enabled: false, classes: 'test2015'};
+            case 2016:
+                return false;
+        }
+    };
+
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('2012-10-26')
+            .datepicker({
+                format: 'yyyy-mm-dd',
+                beforeShowYear: beforeShowYear
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-years tbody span:nth(4)');
+    equal(target.attr('title'), 'Example tooltip', '5th has tooltip');
+    ok(!target.hasClass('disabled'), '2013, 5th is enabled');
+    target = picker.find('.datepicker-years tbody span:nth(5)');
+    ok(target.hasClass('test2014'), '6th has test2014 class');
+    ok(!target.hasClass('disabled'), '2014, 6th is enabled');
+    target = picker.find('.datepicker-years tbody span:nth(6)');
+    ok(target.hasClass('test2015'), '2015, 7th has test2015 class');
+    ok(target.hasClass('disabled'), '2015, 7th is disabled');
+    target = picker.find('.datepicker-years tbody span:nth(7)');
+    ok(target.hasClass('disabled'), '2016, 8th is disabled');
+    target = picker.find('.datepicker-years tbody span:nth(8)');
+    ok(!target.hasClass('disabled'), '2017, 9th is enabled');
+});
+
+test('beforeShowDecade', function () {
+    var beforeShowDecade = function (date) {
+        switch (date.getFullYear()) {
+            case 2030:
+                return {
+                    tooltip: 'Example tooltip',
+                    classes: 'active'
+                };
+            case 2040:
+                return "test2040";
+            case 2050:
+                return {enabled: false, classes: 'test2050'};
+            case 2060:
+                return false;
+        }
+    };
+
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('03/05/2012')
+            .datepicker({ beforeShowDecade: beforeShowDecade }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-decades tbody span:nth(4)');
+    equal(target.attr('title'), 'Example tooltip', '5th has tooltip');
+    ok(!target.hasClass('disabled'), '2030, 5th is enabled');
+
+    target = picker.find('.datepicker-decades tbody span:nth(5)');
+    ok(target.hasClass('test2040'), '6th has test2040 class');
+    ok(!target.hasClass('disabled'), '2040, 6th is enabled');
+
+    target = picker.find('.datepicker-decades tbody span:nth(6)');
+    ok(target.hasClass('test2050'), '2050, 7th has test2050 class');
+    ok(target.hasClass('disabled'), '2050, 7th is disabled');
+
+    target = picker.find('.datepicker-decades tbody span:nth(7)');
+    ok(target.hasClass('disabled'), '2060, 8th is disabled');
+
+    target = picker.find('.datepicker-decades tbody span:nth(8)');
+    ok(!target.hasClass('disabled'), '2070, 9th is enabled');
+});
+
+test('beforeShowCentury', function () {
+    var beforeShowCentury = function (date) {
+        switch (date.getFullYear()) {
+            case 2300:
+                return {
+                    tooltip: 'Example tooltip',
+                    classes: 'active'
+                };
+            case 2400:
+                return "test2400";
+            case 2500:
+                return {enabled: false, classes: 'test2500'};
+            case 2600:
+                return false;
+        }
+    };
+
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('03/05/2012')
+            .datepicker({ beforeShowCentury: beforeShowCentury }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-centuries tbody span:nth(4)');
+    equal(target.attr('title'), 'Example tooltip', '5th has tooltip');
+    ok(!target.hasClass('disabled'), '2300, 5th is enabled');
+
+    target = picker.find('.datepicker-centuries tbody span:nth(5)');
+    ok(target.hasClass('test2400'), '6th has test2400 class');
+    ok(!target.hasClass('disabled'), '2400, 6th is enabled');
+
+    target = picker.find('.datepicker-centuries tbody span:nth(6)');
+    ok(target.hasClass('test2500'), '2500, 7th has test2500 class');
+    ok(target.hasClass('disabled'), '2500, 7th is disabled');
+
+    target = picker.find('.datepicker-centuries tbody span:nth(7)');
+    ok(target.hasClass('disabled'), '2600, 8th is disabled');
+
+    target = picker.find('.datepicker-centuries tbody span:nth(8)');
+    ok(!target.hasClass('disabled'), '2700, 9th is enabled');
+});
+
+test('Orientation: values are parsed correctly', function(){
+
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd'
+                }),
+        dp = input.data('datepicker');
+
+    equal(dp.o.orientation.x, 'auto');
+    equal(dp.o.orientation.y, 'auto');
+
+    dp._process_options({orientation: ''});
+    equal(dp.o.orientation.x, 'auto', 'Empty value');
+    equal(dp.o.orientation.y, 'auto', 'Empty value');
+
+    dp._process_options({orientation: 'left'});
+    equal(dp.o.orientation.x, 'left', '"left"');
+    equal(dp.o.orientation.y, 'auto', '"left"');
+
+    dp._process_options({orientation: 'right'});
+    equal(dp.o.orientation.x, 'right', '"right"');
+    equal(dp.o.orientation.y, 'auto', '"right"');
+
+    dp._process_options({orientation: 'top'});
+    equal(dp.o.orientation.x, 'auto', '"top"');
+    equal(dp.o.orientation.y, 'top', '"top"');
+
+    dp._process_options({orientation: 'bottom'});
+    equal(dp.o.orientation.x, 'auto', '"bottom"');
+    equal(dp.o.orientation.y, 'bottom', '"bottom"');
+
+    dp._process_options({orientation: 'left top'});
+    equal(dp.o.orientation.x, 'left', '"left top"');
+    equal(dp.o.orientation.y, 'top', '"left top"');
+
+    dp._process_options({orientation: 'left bottom'});
+    equal(dp.o.orientation.x, 'left', '"left bottom"');
+    equal(dp.o.orientation.y, 'bottom', '"left bottom"');
+
+    dp._process_options({orientation: 'right top'});
+    equal(dp.o.orientation.x, 'right', '"right top"');
+    equal(dp.o.orientation.y, 'top', '"right top"');
+
+    dp._process_options({orientation: 'right bottom'});
+    equal(dp.o.orientation.x, 'right', '"right bottom"');
+    equal(dp.o.orientation.y, 'bottom', '"right bottom"');
+
+    dp._process_options({orientation: 'left right'});
+    equal(dp.o.orientation.x, 'left', '"left right"');
+    equal(dp.o.orientation.y, 'auto', '"left right"');
+
+    dp._process_options({orientation: 'right left'});
+    equal(dp.o.orientation.x, 'right', '"right left"');
+    equal(dp.o.orientation.y, 'auto', '"right left"');
+
+    dp._process_options({orientation: 'top bottom'});
+    equal(dp.o.orientation.x, 'auto', '"top bottom"');
+    equal(dp.o.orientation.y, 'top', '"top bottom"');
+
+    dp._process_options({orientation: 'bottom top'});
+    equal(dp.o.orientation.x, 'auto', '"bottom top"');
+    equal(dp.o.orientation.y, 'bottom', '"bottom top"');
+
+    dp._process_options({orientation: 'foo bar'});
+    equal(dp.o.orientation.x, 'auto', '"foo bar"');
+    equal(dp.o.orientation.y, 'auto', '"foo bar"');
+
+    dp._process_options({orientation: 'foo left'});
+    equal(dp.o.orientation.x, 'left', '"foo left"');
+    equal(dp.o.orientation.y, 'auto', '"foo left"');
+
+    dp._process_options({orientation: 'top bar'});
+    equal(dp.o.orientation.x, 'auto', '"top bar"');
+    equal(dp.o.orientation.y, 'top', '"top bar"');
+});
+
+test('startDate', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    startDate: new Date(2012, 9, 26)
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(25)');
+    ok(target.hasClass('disabled'), 'Previous day is disabled');
+    target = picker.find('.datepicker-days tbody td:nth(26)');
+    ok(!target.hasClass('disabled'), 'Specified date is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(27)');
+    ok(!target.hasClass('disabled'), 'Next day is enabled');
+});
+
+test('endDate', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    endDate: new Date(2012, 9, 26)
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-days tbody td:nth(25)');
+    ok(!target.hasClass('disabled'), 'Previous day is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(26)');
+    ok(!target.hasClass('disabled'), 'Specified date is enabled');
+    target = picker.find('.datepicker-days tbody td:nth(27)');
+    ok(target.hasClass('disabled'), 'Next day is disabled');
+});
+
+test('Multidate', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    multidate: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+
+    // Initial value is selected
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 (initial date) in dates');
+
+    // Select first
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '4'); // Mar 4
+
+    target.click();
+    datesEqual(dp.dates.get(-1), UTCDate(2012, 2, 4), '2012-03-04 in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+    equal(input.val(), '2012-03-05,2012-03-04');
+
+    // Select second
+    target = picker.find('.datepicker-days tbody td:nth(15)');
+    equal(target.text(), '12'); // Mar 12
+
+    target.click();
+    datesEqual(dp.dates.get(-1), UTCDate(2012, 2, 12), '2012-03-12 in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 12));
+    equal(input.val(), '2012-03-05,2012-03-04,2012-03-12');
+
+    // Deselect first
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '4'); // Mar 4
+
+    target.click();
+    ok(dp.dates.contains(UTCDate(2012, 2, 4)) === -1, '2012-03-04 no longer in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+    equal(input.val(), '2012-03-05,2012-03-12');
+});
+
+test('Multidate with limit', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    multidate: 2
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+
+    // Initial value is selected
+    ok(dp.dates.contains(UTCDate(2012, 2, 5)) !== -1, '2012-03-05 (initial date) in dates');
+
+    // Select first
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '4'); // Mar 4
+
+    target.click();
+    datesEqual(dp.dates.get(-1), UTCDate(2012, 2, 4), '2012-03-04 in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 4));
+    equal(input.val(), '2012-03-05,2012-03-04');
+
+    // Select second
+    target = picker.find('.datepicker-days tbody td:nth(15)');
+    equal(target.text(), '12'); // Mar 12
+
+    target.click();
+    datesEqual(dp.dates.get(-1), UTCDate(2012, 2, 12), '2012-03-12 in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 12));
+    equal(input.val(), '2012-03-04,2012-03-12');
+
+    // Select third
+    target = picker.find('.datepicker-days tbody td:nth(20)');
+    equal(target.text(), '17'); // Mar 17
+
+    target.click();
+    datesEqual(dp.dates.get(-1), UTCDate(2012, 2, 17), '2012-03-17 in dates');
+    ok(dp.dates.contains(UTCDate(2012, 2, 4)) === -1, '2012-03-04 no longer in dates');
+    datesEqual(dp.viewDate, UTCDate(2012, 2, 17));
+    equal(input.val(), '2012-03-12,2012-03-17');
+});
+
+test('Multidate Separator', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    multidate: true,
+                    multidateSeparator: ' '
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+
+    // Select first
+    target = picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '4'); // Mar 4
+
+    target.click();
+    equal(input.val(), '2012-03-05 2012-03-04');
+
+    // Select second
+    target = picker.find('.datepicker-days tbody td:nth(15)');
+    equal(target.text(), '12'); // Mar 12
+
+    target.click();
+    equal(input.val(), '2012-03-05 2012-03-04 2012-03-12');
+});
+
+
+test("Picker is shown on input focus when showOnFocus is not defined", function () {
+
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('2014-01-01')
+            .datepicker({
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+
+    ok(picker.is(":visible"), "Datepicker is visible");
+
+});
+
+test("Picker is shown on input focus when showOnFocus is true", function () {
+
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('2014-01-01')
+            .datepicker({
+                showOnFocus: true
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+
+    ok(picker.is(":visible"), "Datepicker is visible");
+
+});
+
+test("Picker is hidden on input focus when showOnFocus is false", function () {
+
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('2014-01-01')
+            .datepicker({
+                showOnFocus: false
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+
+    ok(picker.is(":hidden"), "Datepicker is hidden");
+
+});
+
+test('Container', function(){
+    var testContainer = $('<div class="date-picker-container"/>')
+            .appendTo('#qunit-fixture'),
+        input = $('<input />')
+            .appendTo('#qunit-fixture')
+                .val('2012-10-26')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    container: '.date-picker-container',
+                    startDate: new Date(2012, 9, 26)
+                }),
+        dp = input.data('datepicker'),
+        target = dp.picker;
+    input.focus();
+    equal(target.parent()[0], testContainer[0], 'Container is not the testContainer that was specificed');
+});
+
+test('Default View Date (Object)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    defaultViewDate: { year: 1977, month: 04, day: 25 }
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+
+    equal(picker.find('.datepicker-days thead .datepicker-switch').text(), 'May 1977');
+});
+
+test('Default View Date (Date)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    defaultViewDate: new Date(1977, 4, 25)
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+
+    equal(picker.find('.datepicker-days thead .datepicker-switch').text(), 'May 1977');
+});
+
+test('Default View Date (String)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    defaultViewDate: "1977-05-24"
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+
+    equal(picker.find('.datepicker-days thead .datepicker-switch').text(), 'May 1977');
+});
+
+test('Immediate Updates', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2014-01-01')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    immediateUpdates: true
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    // Change month
+    input.focus();
+    picker.find('.datepicker-days .next').click();
+    equal(input.val(), '2014-02-01');
+
+    // Change year
+    picker.find('.datepicker-days .datepicker-switch').click();
+    picker.find('.datepicker-months .next').click();
+    equal(input.val(), '2015-02-01');
+
+    // Change decade set (doesn't update input)
+    picker.find('.datepicker-months .datepicker-switch').click();
+    picker.find('.datepicker-years .next').click();
+    equal(input.val(), '2015-02-01');
+
+    // Change century set (doesn't update input)
+    picker.find('.datepicker-years .datepicker-switch').click();
+    picker.find('.datepicker-decades .next').click();
+    equal(input.val(), '2015-02-01');
+
+    // Change millennium set (doesn't update input)
+    picker.find('.datepicker-decades .datepicker-switch').click();
+    picker.find('.datepicker-centuries .next').click();
+    equal(input.val(), '2015-02-01');
+});
+
+test('forceParse: false on enter on invalid date', function () {
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('123456789')
+                .datepicker({forceParse: false})
+                .focus();
+
+    input.trigger({
+        type: 'keydown',
+        keyCode: 13,
+        shiftKey: false
+    });
+
+    equal(input.val(), '123456789', 'date not parsed');
+});
+
+test('forceParse: false on mousedown on invalid date', function () {
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('123456789')
+                .datepicker({forceParse: false})
+                .focus();
+
+    $(document).trigger({
+        type: 'mousedown'
+    });
+
+    equal(input.val(), '123456789', 'date not parsed');
+});
+
+//datepicker-dropdown
+
+test('Enable on readonly options (default)', function(){
+    var input = $('<input readonly="readonly" />')
+            .appendTo('#qunit-fixture')
+            .datepicker({format: "dd-mm-yyyy"}),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    ok(!picker.is(':visible'));
+    input.focus();
+    ok(picker.is(':visible'));
+});
+
+test('Enable on readonly options (false)', function(){
+    var input = $('<input readonly="readonly" />')
+            .appendTo('#qunit-fixture')
+            .datepicker({
+                format: "dd-mm-yyyy",
+                enableOnReadonly: false
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    ok(!picker.is(':visible'));
+    input.focus();
+    ok(!picker.is(':visible'));
+});
+
+test('Startview: year view visible after date pick', function(){
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .datepicker({
+                startView: 2,
+                minViewMode: 1,
+                autoclose: true
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':visible'), 'Years view visible');
+
+    target = picker.find('.datepicker-years tbody td:nth(7)');
+    target.click();
+    target = picker.find('.datepicker-years tbody td:nth(4)');
+    target.click();
+    target = picker.find('.datepicker-years tbody td:nth(20)');
+    target.click();
+
+    input.focus();
+    ok(picker.find('.datepicker-days').is(':not(:visible)'), 'Days view hidden');
+    ok(picker.find('.datepicker-months').is(':not(:visible)'), 'Months view hidden');
+    ok(picker.find('.datepicker-years').is(':visible'), 'Years view visible');
+});
+
+test('Title: none', function(){
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .datepicker({
+                format: 'yyyy-mm-dd'
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.is(':visible'), 'Picker is visible');
+
+    target = picker.find('.datepicker-days thead .datepicker-title');
+    ok(target.is(':not(:visible)'), 'Title is hidden');
+});
+
+test('Title: with value', function(){
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .datepicker({
+                format: 'yyyy-mm-dd',
+                title: 'Some Title'
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.is(':visible'), 'Picker is visible');
+
+    target = picker.find('.datepicker-days thead .datepicker-title');
+    ok(target.is(':visible'), 'Title is visible');
+    equal(target.text(), 'Some Title');
+});
+
+test('i18n: Leverage i18n titleFormat when available.', patch_date(function(Date){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2015年04月21日')
+                .datepicker({
+                    language: 'zh-CN'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+    equal(picker.find('.datepicker-days thead .datepicker-switch').text(), '2015年04月', 'Title is in Chinese: 2015年04月');
+}));
+
+test('i18n: Leverage English (default) i18n titleFormat when translation key for specified language is not available.', patch_date(function(Date){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('04/21/2015')
+                .datepicker({
+                    language: 'aa-BB'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+    equal(picker.find('.datepicker-days thead .datepicker-switch').text(), 'April 2015', 'Title is in default format: April 2015');
+}));
+
+test('Z-index Offset: none', function(){
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .datepicker(),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.parent().css('z-index', 234);
+    input.focus();
+
+    equal(dp.o.zIndexOffset, 10, 'Z-index offset option defaults to 10.');
+    equal(picker.css('z-index'), 244, 'Picker Z-index offset is respected.');
+});
+
+test('Z-index Offset: with value', function(){
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .datepicker({
+                zIndexOffset: 1000
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.parent().css('z-index', 234);
+    input.focus();
+
+    equal(dp.o.zIndexOffset, 1000, 'Z-index offset option is accepted.');
+    equal(picker.css('z-index'), 1234, 'Picker Z-index offset is respected.');
+});
+
+test('templates', function(){
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .datepicker({
+                templates: {
+                    leftArrow: '<span class="glyphicon glyphicon-arrow-left"></span>',
+                    rightArrow: '</table>'
+                }
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+    equal(picker.find('.datepicker-days .prev').prop('innerHTML'), '<span class="glyphicon glyphicon-arrow-left"></span>');
+    equal(picker.find('.datepicker-days .next').prop('innerHTML'), $('<div>').html('&raquo;').text());
+});
+
+test('Nav arrow html templates with span tag', function () {
+    var input = $('<input />')
+            .appendTo('#qunit-fixture')
+            .val('2012-10-26')
+            .datepicker({
+                format: 'yyyy-mm-dd',
+                templates: {
+                    leftArrow: '<span></span>',
+                    rightArrow: '<span></span>'
+                }
+            }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    target = picker.find('.datepicker-months tbody span:nth(9)');
+    ok(target.hasClass('active'), 'Month is selected');
+});
+
+test('Nav arrow html templates .prev click', function () {
+    var input = $('<input />')
+        .appendTo('#qunit-fixture')
+        .val('2012-10-26')
+        .datepicker({
+            format: 'yyyy-mm-dd',
+            startView: 1,
+            templates: {
+                leftArrow: '<i></i>'
+            }
+        }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    picker.find('.datepicker-months thead .prev i').trigger('click');
+    target = picker.find('.datepicker-months thead .datepicker-switch');
+    equal(target.text(), '2011');
+});
+
+test('Visibility of the prev and next arrows for year/decade/century/millenium views with startDate and endDate', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('01/01/2015')
+                .datepicker({
+                    format: 'dd/mm/yyyy',
+                    startView: 1,
+                    startDate: '01/12/2014',
+                    endDate: '01/12/2016'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+
+    target = picker.find('.datepicker-months thead th.prev');
+    ok(!target.hasClass('disabled'), 'Prev switcher is not hidden');
+    target = picker.find('.datepicker-months thead th.next');
+    ok(!target.hasClass('disabled'), 'Next switcher is not hidden');
+
+    picker.find('.datepicker-months thead th.datepicker-switch').click();
+    target = picker.find('.datepicker-years thead th.prev');
+    ok(target.hasClass('disabled'), 'Prev switcher is hidden');
+    target = picker.find('.datepicker-years thead th.next');
+    ok(target.hasClass('disabled'), 'Next switcher is hidden');
+
+    picker.find('.datepicker-years thead th.datepicker-switch').click();
+    target = picker.find('.datepicker-decades thead th.prev');
+    ok(target.hasClass('disabled'), 'Prev switcher is hidden');
+    target = picker.find('.datepicker-decades thead th.next');
+    ok(target.hasClass('disabled'), 'Next switcher is hidden');
+
+    picker.find('.datepicker-decades thead th.datepicker-switch').click();
+    target = picker.find('.datepicker-centuries thead th.prev');
+    ok(target.hasClass('disabled'), 'Prev switcher is hidden');
+    target = picker.find('.datepicker-centuries thead th.next');
+    ok(target.hasClass('disabled'), 'Next switcher is hidden');
+});
+
+test('date cells (outdated)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .datepicker(),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+    picker.find('.datepicker-days .day').each(function(){
+        ok(this.hasAttribute('data-date'));
+    });
+});
+
+test('keepEmptyValues: none (default is false)', function() {
+    var proxy_element = $('<div />').appendTo('#qunit-fixture'),
+        input_from = $('<input />').val('2016-04-01').appendTo('#qunit-fixture'),
+        input_to = $('<input />').appendTo('#qunit-fixture'),
+        dp = proxy_element.datepicker({
+            format: 'yyyy-mm-dd',
+            inputs: [input_from, input_to]
+        }),
+        input_from_dp = input_from.data('datepicker');
+
+    input_from.focus();
+    input_from_dp.picker.find('.old.day').eq(0).click();
+
+    equal(input_from.val(), '2016-03-27');
+    equal(input_to.val(), '2016-03-27', 'Input_from value should be distributed.');
+});
+
+test('keepEmptyValues: true', function() {
+    var proxy_element = $('<div />').appendTo('#qunit-fixture'),
+        input_from = $('<input />').val('2016-04-01').appendTo('#qunit-fixture'),
+        input_to = $('<input />').appendTo('#qunit-fixture'),
+        dp = proxy_element.datepicker({
+            format: 'yyyy-mm-dd',
+            inputs: [input_from, input_to],
+            keepEmptyValues: true
+        }),
+        input_from_dp = input_from.data('datepicker');
+
+    input_from.focus();
+    input_from_dp.picker.find('.old.day').eq(0).click();
+
+    equal(input_from.val(), '2016-03-27');
+    equal(input_to.val(), '', 'Input_from value should not be distributed.');
+});
+
+test('maxViewMode and navigation switch', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .datepicker({
+                    maxViewMode: 0
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker;
+
+    input.focus();
+
+    picker.find('.datepicker-days thead th.datepicker-switch').click();
+    ok(picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+});
+
+test('updateViewDate', function() {
+    expect(8);
+
+    var input = $('<input value="08/03/1990"/>')
+                .appendTo('#qunit-fixture')
+                .datepicker({
+                  defaultViewDate: {
+                    year: 1945,
+                    month: 4,
+                    day: 8
+                  },
+                  updateViewDate: false
+                })
+                .on('changeMonth', function() {
+                  var msg = shouldTriggerChangeMonth ? 'changeMonth must be triggered' : 'changeMonth must not be triggered';
+                  ok(shouldTriggerChangeMonth, msg);
+                })
+                .on('changeYear', function() {
+                  var msg = shouldTriggerChangeYear ? 'changeYear must be triggered' : 'changeYear must not be triggered';
+                  ok(shouldTriggerChangeYear, msg);
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        shouldTriggerChangeMonth = false,
+        shouldTriggerChangeYear = false,
+        monthShown = picker.find('.datepicker-days thead th.datepicker-switch');
+
+    equal(monthShown.text(), "May 1945", 'uses defaultViewDate on initialization');
+    input.datepicker('setDate', new Date(1945, 8, 2));
+    equal(monthShown.text(), "May 1945", 'does not change viewDate on `setDate` method');
+    input.focus();
+    picker.find('.datepicker-days tbody tr td.day.new:first').click();
+    equal(monthShown.text(), "May 1945", 'does not change viewDate if a day in next month is selected');
+    shouldTriggerChangeMonth = true;
+    picker.find('.datepicker-days thead th.next').click();
+    equal(monthShown.text(), 'June 1945', 'changing month must still be possible'); // and must trigger `changeMonth` event
+    shouldTriggerChangeYear = true;
+    picker.find('.datepicker-days thead th.datepicker-switch').click();
+    picker.find('.datepicker-months thead th.next').click();
+    picker.find('.datepicker-months tbody .month:first').click();
+    equal(monthShown.text(), 'January 1946', 'changing year must still be possible'); // and must trigger `changeYear` and `changeMonth` events
+});
+test('Week Days: Week days default visibility (or enabled)', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd'
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.dow').length > 0, 'Week days added to view');
+});
+test('Week Days: Week days visibility when disabled', function(){
+    var input = $('<input />')
+                .appendTo('#qunit-fixture')
+                .val('2012-03-05')
+                .datepicker({
+                    format: 'yyyy-mm-dd',
+                    showWeekDays: false
+                }),
+        dp = input.data('datepicker'),
+        picker = dp.picker,
+        target;
+
+    input.focus();
+    ok(picker.find('.dow').length === 0, 'Week days not added to view');
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/timezone.js b/public/bower_components/bootstrap-datepicker/tests/suites/timezone.js
new file mode 100644
index 0000000..f522c5c
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/timezone.js
@@ -0,0 +1,24 @@
+module('Component', {
+    setup: function(){
+        this.component = $('<div class="input-append date" id="datepicker">'+
+                               '<input type="text">'+
+                           '</div>')
+                        .appendTo('#qunit-fixture')
+                        .datepicker();
+        this.dp = this.component.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Check title with timezone', function(){
+    var target;
+
+    this.dp.viewDate = UTCDate(2015, 7, 1);
+    this.dp.fill();
+
+    target = this.picker.find('.datepicker-days .datepicker-switch');
+    equal(target.text(), 'August 2015', 'Title is "August 2015"');
+});
diff --git a/public/bower_components/bootstrap-datepicker/tests/suites/touch_navigation/all.js b/public/bower_components/bootstrap-datepicker/tests/suites/touch_navigation/all.js
new file mode 100644
index 0000000..99b570d
--- /dev/null
+++ b/public/bower_components/bootstrap-datepicker/tests/suites/touch_navigation/all.js
@@ -0,0 +1,27 @@
+module('Touch Navigation (All)', {
+    setup: function(){
+        this.input = $('<input type="text">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Tapping outside datepicker hides datepicker', function(){
+    var $otherelement = $('<div />');
+    $('body').append($otherelement);
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    this.input.trigger('click');
+    ok(this.picker.is(':visible'), 'Picker is still visible');
+
+    $otherelement.trigger('touchstart');
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+
+    $otherelement.remove();
+});