1
0
Fork 0
liza/test/validate/ValidStateMonitorTest.js

229 lines
6.6 KiB
JavaScript
Raw Normal View History

/**
* Test field validity monitor
*
* Copyright (C) 2016 LoVullo Associates, Inc.
*
* This file is part of liza.
*
* liza is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
var Sut = require( '../../' ).validate.ValidStateMonitor,
expect = require( 'chai' ).expect;
var nocall = function( type )
{
return function()
{
throw Error( type + ' should not be called' );
};
};
describe( 'ValidStateMonitor', function()
{
describe( '#update', function()
{
it( 'does nothing with no data or failures', function()
{
Sut()
.on( 'failure', nocall( 'failure' ) )
.on( 'fix', nocall( 'fix' ) )
.update( {}, {} );
} );
it( 'does nothing with data but no failures', function()
{
Sut()
.on( 'failure', nocall( 'failure' ) )
.on( 'fix', nocall( 'fix' ) )
.update( { foo: [ 'bar' ] }, {} );
} );
// the failure should contain the value that caused it, so we do not
// need the data
describe( 'given failures', function()
{
it( 'marks failures even when given no data', function( done )
{
Sut()
.on( 'failure', function( failures )
{
expect( failures )
.to.deep.equal( { foo: [ 'bar', 'baz' ] } );
done();
} )
.on( 'fix', nocall( 'fix' ) )
.update( {}, { foo: [ 'bar', 'baz' ] } );
} );
it( 'marks failures with index gaps', function( done )
{
Sut()
.on( 'failure', function( failures )
{
expect( failures )
.to.deep.equal( { foo: [ undefined, 'baz' ] } );
done();
} )
.on( 'fix', nocall( 'fix' ) )
.update( {}, { foo: [ undefined, 'baz' ] } );
} );
it( 'retains past failures when setting new', function( done )
{
var sut = Sut();
var test_first = function( failures )
{
expect( failures )
.to.deep.equal( { foo: [ undefined, 'baz' ] } );
sut.once( 'failure', test_second );
};
var test_second = function( failures )
{
expect( failures )
.to.deep.equal( { foo: [ 'bar', 'baz' ] } );
done();
};
sut
.once( 'failure', test_first )
.on( 'fix', nocall( 'fix' ) )
.update( {}, { foo: [ undefined, 'baz' ] } )
.update( {}, { foo: [ 'bar' ] } );
} );
} );
describe( 'given data with absence of failure', function()
{
it( 'removes non-failures if field is present', function( done )
{
var data = { foo: [ 'bardata', 'baz' ] };
Sut()
.on( 'fix', function( fixed )
{
expect( fixed )
.to.deep.equal( { foo: [ 'bardata' ] } );
done();
} )
.update( data, { foo: [ 'bar', 'baz' ] } )
.update( data, { foo: [ '', 'baz' ] } );
} );
it( 'keeps failures if field is missing', function( done )
{
var data = {
bar: [ 'baz', 'quux' ],
};
Sut()
.on( 'fix', function( fixed )
{
expect( fixed )
.to.deep.equal( { bar: [ 'baz', 'quux' ] } );
done();
} )
.update( data, {
foo: [ 'bar', 'baz' ], // does not exist in data
bar: [ 'moo', 'cow' ],
} )
.update( data, {} );
} );
} );
it( 'can emit both failure and fix', function( done )
{
var data = {
bar: [ 'baz', 'quux' ],
};
Sut()
.update( data, {
bar: [ 'moo', 'cow' ] // fail
} )
.on( 'failure', function( failed )
{
expect( failed )
.to.deep.equal( {
foo: [ 'bar' ],
} );
} )
.on( 'fix', function( fixed )
{
expect( fixed )
.to.deep.equal( { bar: [ 'baz', 'quux' ] } );
done();
} )
.update( data, {
foo: [ 'bar' ], // fail
// fixes bar
} );
} );
} );
describe( '#getFailures', function()
{
it( 'is empty when no failures exist', function()
{
expect(
Sut()
.getFailures()
).to.deep.equal( {} );
} );
it( 'retrieves current failures', function()
{
expect(
Sut()
.update( {}, { foo: [ 'fail' ] } )
.getFailures()
).to.deep.equal( { foo: [ 'fail' ] } );
} );
} );
describe( '#hasFailures', function()
{
it( 'is false when no failures exist', function()
{
expect( Sut().hasFailures() )
.to.be.false;
} );
it( 'is true when failures exist', function()
{
expect(
Sut()
.update( {}, { foo: [ 'fail' ] } )
.hasFailures()
).to.be.true;
} );
} );
} );