Add tests.

src/predicate.ts

@@ -152,7 +152,7 @@ export function isFieldOneOfPredicate(predicate: any): predicate is FieldOneOfPr
 }
 
 export function isFieldValidPredicate(predicate: any): predicate is FieldValidPredicate {
-  return predicate && !!predicate.field && predicate.valid;
+  return predicate && !!predicate.field && predicate.valid !== undefined;
 }
 
 export function isFieldPredicate(
@@ -228,7 +228,7 @@ export function fieldFilterExpression(predicate: FieldPredicate, useInRange = tr
   } else if (isFieldOneOfPredicate(predicate)) {
     return `indexof([${predicateValuesExpr(predicate.oneOf, timeUnit).join(',')}], ${fieldExpr}) !== -1`;
   } else if (isFieldValidPredicate(predicate)) {
-    return `${fieldExpr} !== null && !isNaN(${fieldExpr})`;
+    return `${fieldExpr}!==null&&!isNaN(${fieldExpr})`;
   } else if (isFieldRangePredicate(predicate)) {
     const lower = predicate.range[0];
     const upper = predicate.range[1];

test/predicate.test.ts

@@ -1,29 +1,42 @@
 import {assert} from 'chai';
-
 import {
   expression,
   fieldFilterExpression,
   isFieldEqualPredicate,
   isFieldLTEPredicate,
   isFieldOneOfPredicate,
-  isFieldRangePredicate
+  isFieldRangePredicate,
+  isFieldValidPredicate,
+  Predicate
 } from '../src/predicate';
 import {TimeUnit} from '../src/timeunit';
+import {without} from '../src/util';
+import {FieldValidPredicate} from './../src/predicate';
 
 describe('filter', () => {
   const equalFilter = {field: 'color', equal: 'red'};
   const oneOfFilter = {field: 'color', oneOf: ['red', 'yellow']};
   const rangeFilter = {field: 'x', range: [0, 5]};
   const exprFilter = 'datum["x"]===5';
   const lessThanEqualsFilter = {field: 'x', lte: 'z'};
+  const validFilter: FieldValidPredicate = {field: 'x', valid: true};
+
+  const allFilters: Predicate[] = [
+    equalFilter,
+    lessThanEqualsFilter,
+    oneOfFilter,
+    rangeFilter,
+    validFilter,
+    exprFilter
+  ];
 
   describe('isEqualFilter', () => {
     it('should return true for an equal filter', () => {
       assert.isTrue(isFieldEqualPredicate(equalFilter));
     });
 
     it('should return false for other filters', () => {
-      [oneOfFilter, rangeFilter, exprFilter].forEach(filter => {
+      without(allFilters, [equalFilter]).forEach(filter => {
         assert.isFalse(isFieldEqualPredicate(filter));
       });
     });
@@ -35,7 +48,7 @@ describe('filter', () => {
     });
 
     it('should return false for other filters', () => {
-      [equalFilter, oneOfFilter, rangeFilter, exprFilter].forEach(filter => {
+      without(allFilters, [lessThanEqualsFilter]).forEach(filter => {
         assert.isFalse(isFieldLTEPredicate(filter));
       });
     });
@@ -47,7 +60,7 @@ describe('filter', () => {
     });
 
     it('should return false for other filters', () => {
-      [equalFilter, rangeFilter, exprFilter].forEach(filter => {
+      without(allFilters, [oneOfFilter]).forEach(filter => {
         assert.isFalse(isFieldOneOfPredicate(filter));
       });
     });
@@ -59,12 +72,24 @@ describe('filter', () => {
     });
 
     it('should return false for other filters', () => {
-      [oneOfFilter, equalFilter, exprFilter].forEach(filter => {
+      without(allFilters, [rangeFilter]).forEach(filter => {
         assert.isFalse(isFieldRangePredicate(filter));
       });
     });
   });
 
+  describe('isValidFilter', () => {
+    it('should return true for a valid filter', () => {
+      assert.isTrue(isFieldValidPredicate(validFilter));
+    });
+
+    it('should return false for other filters', () => {
+      without(allFilters, [validFilter]).forEach(filter => {
+        assert.isFalse(isFieldValidPredicate(filter));
+      });
+    });
+  });
+
   describe('expression', () => {
     it('should return a correct expression for an EqualFilter', () => {
       const expr = expression(null, {field: 'color', equal: 'red'});
@@ -91,6 +116,11 @@ describe('filter', () => {
       assert.equal(expr, 'datum["x"]>=1');
     });
 
+    it('should return correct expression for valid', () => {
+      const expr = expression(null, {field: 'x', valid: true});
+      assert.equal(expr, 'datum["x"]!==null&&!isNaN(datum["x"])');
+    });
+
     it('should return a correct expression for an EqualFilter with datetime object', () => {
       const expr = expression(null, {
         field: 'date',