unit tests for filters

src/filters.js

@@ -12,19 +12,32 @@ var keyCodes = {
 module.exports = {
 
     capitalize: function (value) {
-        if (!value) return ''
+        if (!value && value !== 0) return ''
         value = value.toString()
         return value.charAt(0).toUpperCase() + value.slice(1)
     },
 
     uppercase: function (value) {
-        return value ? value.toString().toUpperCase() : ''
+        return (value || value === 0)
+            ? value.toString().toUpperCase()
+            : ''
     },
 
     lowercase: function (value) {
-        return value ? value.toString().toLowerCase() : ''
+        return (value || value === 0)
+            ? value.toString().toLowerCase()
+            : ''
     },
 
+    /*
+     *  args: an array of strings corresponding to
+     *  the single, double, triple ... forms of the word to
+     *  be pluralized. When the number to be pluralized
+     *  exceeds the length of the args, it will use the last
+     *  entry in the array.
+     *
+     *  e.g. ['single', 'double', 'triple', 'multiple']
+     */
     pluralize: function (value, args) {
         return args.length > 1
             ? (args[value - 1] || args[args.length - 1])
@@ -32,12 +45,13 @@ module.exports = {
     },
 
     currency: function (value, args) {
-        if (!value) return ''
+        if (!value && value !== 0) return ''
         var sign = (args && args[0]) || '$',
-            i = value % 3,
-            f = '.' + value.toFixed(2).slice(-2),
-            s = Math.floor(value).toString()
-        return sign + s.slice(0, i) + s.slice(i).replace(/(\d{3})(?=\d)/g, '$1,') + f
+            s = Math.floor(value).toString(),
+            i = s.length % 3,
+            h = i > 0 ? (s.slice(0, i) + (s.length > 3 ? ',' : '')) : '',
+            f = '.' + value.toFixed(2).slice(-2)
+        return sign + h + s.slice(i).replace(/(\d{3})(?=\d)/g, '$1,') + f
     },
 
     key: function (handler, args) {

test/unit/runner.html

@@ -13,7 +13,8 @@
 		<script src="../seed.test.js"></script>
 		<script>
 			mocha.setup('bdd')
-			var assert = chai.assert
+			var seed = require('seed'),
+				assert = chai.assert
 
 			function mock (id, html, opts) {
 				var el = document.createElement('div')

test/unit/specs/api.js

@@ -1,5 +1,3 @@
-var seed = require('seed')
-
 describe('UNIT: API', function () {
 
     describe('ViewModel.extend()', function () {

test/unit/specs/directive.js

@@ -168,7 +168,7 @@ describe('UNIT: Directive', function () {
         it('should apply the filter if there is any', function () {
             var d = Directive.parse('sd-applyTest', 'abc | currency £')
             d.apply(12345)
-            assert.strictEqual(test, '£123,45.00')
+            assert.strictEqual(test, '£12,345.00')
         })
 
     })

test/unit/specs/filters.js

@@ -1,5 +1,152 @@
 var filters = require('seed/src/filters')
 
 describe('UNIT: Filters', function () {
-    // body...
-})
+    
+    describe('capitalize', function () {
+
+        var filter = filters.capitalize
+
+        it('should capitalize a string', function () {
+            var res = filter('fsefsfsef')
+            assert.strictEqual(res.charAt(0), 'F')
+            assert.strictEqual(res.slice(1), 'sefsfsef')
+        })
+
+        assertNumberAndFalsy(filter)
+
+    })
+
+    describe('uppercase', function () {
+
+        var filter = filters.uppercase
+        
+        it('should uppercase a string', function () {
+            var res = filter('fsefef')
+            assert.strictEqual(res, 'FSEFEF')
+        })
+
+        assertNumberAndFalsy(filter)
+
+    })
+
+    describe('lowercase', function () {
+        
+        var filter = filters.lowercase
+
+        it('should lowercase a string', function () {
+            var res = filter('AweSoMe')
+            assert.strictEqual(res, 'awesome')
+        })
+
+        assertNumberAndFalsy(filter)
+
+    })
+
+    describe('pluralize', function () {
+        
+        var filter = filters.pluralize
+
+        it('should simply add "s" if arg length is 1', function () {
+            var args = ['item'],
+                res0 = filter(0, args),
+                res1 = filter(1, args),
+                res2 = filter(2, args)
+            assert.strictEqual(res0, 'items')
+            assert.strictEqual(res1, 'item')
+            assert.strictEqual(res2, 'items')
+        })
+
+        it('should use corresponding format when arg length is greater than 1', function () {
+            var args = ['st', 'nd', 'rd'],
+                res0 = filter(0, args),
+                res1 = filter(1, args),
+                res2 = filter(2, args),
+                res3 = filter(3, args)
+            assert.strictEqual(res0, 'rd')
+            assert.strictEqual(res1, 'st')
+            assert.strictEqual(res2, 'nd')
+            assert.strictEqual(res3, 'rd')
+        })
+
+    })
+
+    describe('currency', function () {
+        
+        var filter = filters.currency
+
+        it('should format a number correctly', function () {
+            var res1 = filter(1234),
+                res2 = filter(1234.45),
+                res3 = filter(123443434.4343434)
+            assert.strictEqual(res1, '$1,234.00')
+            assert.strictEqual(res2, '$1,234.45')
+            assert.strictEqual(res3, '$123,443,434.43')
+        })
+
+        it('should use the arg for the currency sign', function () {
+            var res = filter(2134, '@')
+            assert.strictEqual(res, '@2,134.00')
+        })
+
+        it('should return empty string on falsy values except 0', function () {
+            var res1 = filter(false),
+                res2 = filter(null),
+                res3 = filter(undefined),
+                res4 = filter(0)
+            assert.strictEqual(res1, '')
+            assert.strictEqual(res2, '')
+            assert.strictEqual(res3, '')
+            assert.strictEqual(res4, '$0.00')
+        })
+
+    })
+
+    describe('key', function () {
+
+        var filter = filters.key
+
+        it('should return a function that only triggers when key matches', function () {
+            var args = ['enter'],
+                triggered = false,
+                handler = filter(function () {
+                    triggered = true
+                }, args)
+            handler({ keyCode: 0 })
+            assert.notOk(triggered)
+            handler({ keyCode: 13 })
+            assert.ok(triggered)
+        })
+
+        it('should also work for direct keyCode', function () {
+            var args = [13],
+                triggered = false,
+                handler = filter(function () {
+                    triggered = true
+                }, args)
+            handler({ keyCode: 0 })
+            assert.notOk(triggered)
+            handler({ keyCode: 13 })
+            assert.ok(triggered)
+        })
+
+    })
+
+})
+
+function assertNumberAndFalsy (filter) {
+    it('should return a stringified number', function () {
+        var res = filter(12345)
+        assert.strictEqual(res, '12345')
+    })
+
+    it('should return empty string on falsy values except 0', function () {
+        var res1 = filter(false),
+            res2 = filter(null),
+            res3 = filter(undefined),
+            res4 = filter(0)
+        assert.strictEqual(res1, '')
+        assert.strictEqual(res2, '')
+        assert.strictEqual(res3, '')
+        assert.strictEqual(res4, '0')
+    })
+}