462 lines
15 KiB
JavaScript
462 lines
15 KiB
JavaScript
/**
|
|
* Test field validity monitor
|
|
*
|
|
* Copyright (C) 2016, 2017 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 root = require( '../../' ),
|
|
Sut = root.validate.ValidStateMonitor,
|
|
chai = require( 'chai' ),
|
|
expect = chai.expect,
|
|
Failure = root.validate.Failure,
|
|
Field = root.field.BucketField;
|
|
|
|
chai.use( require( 'chai-as-promised' ) );
|
|
|
|
|
|
var nocall = function( type )
|
|
{
|
|
return function()
|
|
{
|
|
throw Error( type + ' should not be called' );
|
|
};
|
|
};
|
|
|
|
var mkfail = function( name, arr )
|
|
{
|
|
return arr.map( function( value, i )
|
|
{
|
|
return ( value === undefined )
|
|
? undefined
|
|
: Failure( Field( name, i ), value );
|
|
} );
|
|
};
|
|
|
|
|
|
describe( 'ValidStateMonitor', function()
|
|
{
|
|
describe( '#update', function()
|
|
{
|
|
it( 'does nothing with no data or failures', function()
|
|
{
|
|
return Sut()
|
|
.on( 'failure', nocall( 'failure' ) )
|
|
.on( 'fix', nocall( 'fix' ) )
|
|
.update( {}, {} );
|
|
} );
|
|
|
|
|
|
it( 'does nothing with data but no failures', function()
|
|
{
|
|
return Sut()
|
|
.on( 'failure', nocall( 'failure' ) )
|
|
.on( 'fix', nocall( 'fix' ) )
|
|
.update( { foo: mkfail( '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 )
|
|
{
|
|
var fail = mkfail( 'foo', [ 'bar', 'baz' ] );
|
|
|
|
Sut()
|
|
.on( 'failure', function( failures )
|
|
{
|
|
expect( failures )
|
|
.to.deep.equal( { foo: [ fail[ 0 ], fail[ 1 ] ] } );
|
|
done();
|
|
} )
|
|
.on( 'fix', nocall( 'fix' ) )
|
|
.update( {}, { foo: fail } );
|
|
} );
|
|
|
|
|
|
it( 'marks failures with index gaps', function( done )
|
|
{
|
|
var fail = mkfail( 'foo', [ undefined, 'baz' ] );
|
|
|
|
Sut()
|
|
.on( 'failure', function( failures )
|
|
{
|
|
expect( failures )
|
|
.to.deep.equal( { foo: [ undefined, fail[ 1 ] ] } );
|
|
done();
|
|
} )
|
|
.on( 'fix', nocall( 'fix' ) )
|
|
.update( {}, { foo: fail } );
|
|
} );
|
|
|
|
|
|
it( 'retains past failures when setting new', function( done )
|
|
{
|
|
var sut = Sut(),
|
|
fail = mkfail( 'foo', [ 'bar', 'baz' ] );
|
|
|
|
var test_first = function( failures )
|
|
{
|
|
expect( failures )
|
|
.to.deep.equal( { foo: [ undefined, fail[ 1 ] ] } );
|
|
|
|
sut.once( 'failure', test_second );
|
|
};
|
|
|
|
var test_second = function( failures )
|
|
{
|
|
expect( failures )
|
|
.to.deep.equal( { foo: [ fail[ 0 ], fail[ 1 ] ] } );
|
|
|
|
done();
|
|
};
|
|
|
|
sut
|
|
.once( 'failure', test_first )
|
|
.on( 'fix', nocall( 'fix' ) )
|
|
.update( {}, { foo: [ undefined, fail[ 1 ] ] } )
|
|
.then( () =>
|
|
{
|
|
return sut.update( {}, { foo: [ fail[ 0 ] ] } );
|
|
} );
|
|
} );
|
|
|
|
|
|
// deprecated
|
|
it( 'accepts failures as string for BC', function( done )
|
|
{
|
|
var fail = [ 'foo', 'bar' ];
|
|
|
|
Sut()
|
|
.on( 'failure', function( failures )
|
|
{
|
|
expect( failures )
|
|
.to.deep.equal( { foo: fail } );
|
|
done();
|
|
} )
|
|
.on( 'fix', nocall( 'fix' ) )
|
|
.update( {}, { foo: fail } );
|
|
} );
|
|
|
|
|
|
it( 'does not discard existing failures', function( done )
|
|
{
|
|
var sut = Sut();
|
|
|
|
// has both failures
|
|
var fail1 = Failure(
|
|
Field( 'foo', 0 ),
|
|
'',
|
|
[ Field( 'cause1', 0 ), Field( 'cause2', 0 ) ]
|
|
);
|
|
|
|
// has only one of the two failures
|
|
var fail2 = Failure(
|
|
Field( 'foo', 1 ),
|
|
'',
|
|
[ Field( 'cause2', 1 ) ]
|
|
);
|
|
|
|
// the second failure has fewer causes than the first;
|
|
// we need to make sure that it doesn't overwrite,
|
|
// leading to fewer caues
|
|
sut
|
|
.update( {}, { foo: [ fail1 ] } )
|
|
.then( () =>
|
|
{
|
|
return sut.update( {}, { foo: [ fail2 ] } );
|
|
} )
|
|
.then( () =>
|
|
{
|
|
return sut
|
|
.once( 'fix', function( fixed )
|
|
{
|
|
expect( fixed )
|
|
.to.deep.equal( { foo: [ 'causefix1' ] } );
|
|
|
|
// and then we should have no failures
|
|
expect( sut.hasFailures() ).to.be.false;
|
|
|
|
done();
|
|
} )
|
|
.update(
|
|
{ foo: [ 'moo' ], cause1: [ 'causefix1' ] },
|
|
{}
|
|
);
|
|
} );
|
|
} );
|
|
} );
|
|
|
|
|
|
describe( 'given data with absence of failure', function()
|
|
{
|
|
it( 'removes non-failures if field is present', function( done )
|
|
{
|
|
var data = { foo: [ 'bardata', 'baz' ] },
|
|
fail = mkfail( 'foo', [ 'bar', 'baz' ] );
|
|
|
|
var sut = Sut();
|
|
|
|
sut
|
|
.on( 'fix', function( fixed )
|
|
{
|
|
expect( fixed )
|
|
.to.deep.equal( { foo: [ 'bardata' ] } );
|
|
done();
|
|
} )
|
|
.update( data, { foo: [ fail[ 0 ], fail[ 1 ] ] } )
|
|
.then( () =>
|
|
{
|
|
return sut.update( data, { foo: [ undefined, fail[ 1 ] ] } );
|
|
} );
|
|
} );
|
|
|
|
|
|
it( 'keeps failures if field is missing', function( done )
|
|
{
|
|
var data = { bar: [ 'baz', 'quux' ] },
|
|
fail_foo = mkfail( 'foo', [ 'bar', 'baz' ] ),
|
|
fail_bar = mkfail( 'bar', [ 'moo', 'cow' ] );
|
|
|
|
Sut()
|
|
.on( 'fix', function( fixed )
|
|
{
|
|
expect( fixed )
|
|
.to.deep.equal( { bar: [ 'baz', 'quux' ] } );
|
|
done();
|
|
} )
|
|
.update( data, {
|
|
foo: fail_foo, // does not exist in data
|
|
bar: fail_bar,
|
|
} )
|
|
.then( sut =>
|
|
{
|
|
return sut.update( data, {} );
|
|
} );
|
|
} );
|
|
|
|
|
|
it( 'does not trigger failure event for existing', function()
|
|
{
|
|
var called = 0;
|
|
|
|
Sut()
|
|
.on( 'failure', function()
|
|
{
|
|
called++;
|
|
} )
|
|
.update( {}, { foo: mkfail( 'foo', [ 'bar' ] ) } )
|
|
.then( sut =>
|
|
{
|
|
return sut.update( {}, {} ); // do not trigger failure event
|
|
} )
|
|
.then( sut =>
|
|
{
|
|
expect( called ).to.equal( 1 );
|
|
} );
|
|
} );
|
|
|
|
|
|
describe( 'given a cause', function()
|
|
{
|
|
it( 'considers when recognizing fix', function( done )
|
|
{
|
|
// same index
|
|
var data = { cause: [ 'bar' ] },
|
|
field = Field( 'foo', 0 ),
|
|
cause = Field( 'cause', 0 ),
|
|
fail = Failure( field, 'reason', [ cause ] );
|
|
|
|
Sut()
|
|
.on( 'fix', function( fixed )
|
|
{
|
|
expect( fixed )
|
|
.to.deep.equal( { foo: [ 'bar' ] } );
|
|
|
|
done();
|
|
} )
|
|
.update( data, { foo: [ fail ] } )
|
|
.then( sut =>
|
|
{
|
|
return sut.update( data, {} );
|
|
} );
|
|
} );
|
|
|
|
|
|
it( 'considers different cause index', function( done )
|
|
{
|
|
// different index
|
|
var data = { cause: [ undefined, 'bar' ] },
|
|
field = Field( 'foo', 0 ),
|
|
cause = Field( 'cause', 1 ),
|
|
fail = Failure( field, 'reason', [ cause ] );
|
|
|
|
Sut()
|
|
.on( 'fix', function( fixed )
|
|
{
|
|
expect( fixed )
|
|
.to.deep.equal( { foo: [ 'bar' ] } );
|
|
|
|
done();
|
|
} )
|
|
.update( data, { foo: [ fail ] } )
|
|
.then( sut =>
|
|
{
|
|
return sut.update( data, {} );
|
|
} );
|
|
} );
|
|
|
|
|
|
it( 'considers any number of causes', function( done )
|
|
{
|
|
// different index
|
|
var data = { cause_fix: [ undefined, 'bar' ] },
|
|
field = Field( 'foo', 0 ),
|
|
cause1 = Field( 'cause_no', 1 ),
|
|
cause2 = Field( 'cause_fix', 1 ),
|
|
fail = Failure(
|
|
field,
|
|
'reason',
|
|
[ cause1, cause2 ]
|
|
);
|
|
|
|
Sut()
|
|
.on( 'fix', function( fixed )
|
|
{
|
|
expect( fixed )
|
|
.to.deep.equal( { foo: [ 'bar' ] } );
|
|
|
|
done();
|
|
} )
|
|
.update( data, { foo: [ fail ] } )
|
|
.then( sut =>
|
|
{
|
|
return sut.update( data, {} );
|
|
} );
|
|
} );
|
|
|
|
|
|
it( 'recognizes non-fix', function()
|
|
{
|
|
// no cause data
|
|
var data = { noncause: [ undefined, 'bar' ] },
|
|
field = Field( 'foo', 0 ),
|
|
cause1 = Field( 'cause', 1 ),
|
|
cause2 = Field( 'cause', 2 ),
|
|
fail = Failure(
|
|
field,
|
|
'reason',
|
|
[ cause1, cause2 ]
|
|
);
|
|
|
|
Sut()
|
|
.on( 'fix', nocall )
|
|
.update( data, { foo: [ fail ] } )
|
|
.then( sut =>
|
|
{
|
|
return sut.update( data, {} );
|
|
} );
|
|
} );
|
|
} );
|
|
} );
|
|
|
|
|
|
it( 'can emit both failure and fix', function( done )
|
|
{
|
|
var data = { bar: [ 'baz', 'quux' ] },
|
|
fail_foo = mkfail( 'foo', [ 'bar' ] );
|
|
|
|
Sut()
|
|
.update( data, {
|
|
bar: mkfail( 'bar', [ 'moo', 'cow' ] ) // fail
|
|
} )
|
|
.then( sut =>
|
|
{
|
|
return sut.on( 'failure', function( failed )
|
|
{
|
|
expect( failed )
|
|
.to.deep.equal( {
|
|
foo: fail_foo,
|
|
} );
|
|
} )
|
|
.on( 'fix', function( fixed )
|
|
{
|
|
expect( fixed )
|
|
.to.deep.equal( { bar: [ 'baz', 'quux' ] } );
|
|
done();
|
|
} )
|
|
.update( data, {
|
|
foo: fail_foo, // 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()
|
|
{
|
|
var fail = mkfail( 'foo', [ 'fail' ] );
|
|
|
|
return expect(
|
|
Sut()
|
|
.update( {}, { foo: fail } )
|
|
.then( sut =>
|
|
{
|
|
return sut.getFailures()
|
|
} )
|
|
).to.eventually.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()
|
|
{
|
|
return expect(
|
|
Sut()
|
|
.update( {}, { foo: mkfail( 'foo', [ 'bar' ] ) } )
|
|
.then( sut =>
|
|
{
|
|
return sut.hasFailures();
|
|
} )
|
|
).to.eventually.be.true;
|
|
} );
|
|
} );
|
|
} );
|