added reset_errors and all_errors to validator (real reporter is still pending),

rewriten validator tests

git-svn-id: svn+ssh://mjesec/home/dpavlin/svn/webpac2/trunk@653 07558da8-63fa-0310-ba24-9fe276d99e06

diff --git a/lib/WebPAC/Validate.pm b/lib/WebPAC/Validate.pm
index ae1471b..720f02d 100644 (file)
--- a/lib/WebPAC/Validate.pm
+++ b/lib/WebPAC/Validate.pm
@@ -117,7 +117,7 @@ sub new {
 
 Validate record and return errors
 
-  my @errors = $validate->validate_errors( $rec );
+  my @errors = $validate->validate_errors( $rec, $rec_dump );
 
 =cut
 
@@ -127,6 +127,7 @@ sub validate_errors {
        my $log = $self->_get_logger();
 
        my $rec = shift || $log->logdie("validate_errors need record");
+       my $rec_dump = shift;
 
        $log->logdie("rec isn't HASH") unless (ref($rec) eq 'HASH');
        $log->logdie("can't find validation rules") unless (my $r = $self->{rules});
@@ -160,9 +161,9 @@ sub validate_errors {
                                # are values hashes? (has subfields)
                                if (! defined($v)) {
                                        $errors->{field}->{$f}->{empty} = undef;
-                                       $errors->{dump}->{record}++;
+                                       $errors->{dump} = $rec_dump if ($rec_dump);
                                } elsif (ref($v) ne 'HASH') {
-                                       $errors->{field}->{$f}->{missing_subfield} = "value without subfields: $v";
+                                       $errors->{field}->{$f}->{missing_subfield} = "subfields required for this field";
                                        next;
                                } else {
 
@@ -184,7 +185,7 @@ sub validate_errors {
                                                                $sf_repeatable->{$sf}++;
                                                        };
                                                        if (! first { $_ eq $sf } @{ $r->{$f} }) {
-                                                               $errors->{field}->{ $f }->{subfield}->{$sf} = "unknown";
+                                                               $errors->{field}->{ $f }->{subfield}->{$sf} = "found extra subfield $sf which shouldn't exist";
                                                        }
                                                }
 
@@ -193,7 +194,7 @@ sub validate_errors {
 
                                                foreach my $sf (@r_sf) {
                                                        $errors->{field}->{$f}->{subfield}->{$sf} = "repeatable";
-                                                       $errors->{dump}->{field}->{$f} =
+                                                       $errors->{field}->{$f}->{dump}->{$f} =
                                                                join('', _pack_subfields_hash( $h, 1 ) );
                                                }
 
@@ -210,7 +211,7 @@ sub validate_errors {
                                }
                        } elsif (ref($v) eq 'HASH') {
                                $errors->{field}->{$f}->{unexpected_subfields}++;
-                               $errors->{dump}->{field}->{$f} =
+                               $errors->{field}->{$f}->{dump} =
                                        join('', _pack_subfields_hash( $v, 1 ) );
                        }
                }
@@ -219,13 +220,13 @@ sub validate_errors {
        foreach my $must (sort keys %{ $self->{must_exist} }) {
                next if ($fields->{$must});
                $errors->{field}->{$must}->{missing}++;
-               $errors->{dump}->{record}++;
+               $errors->{dump} = $rec_dump if ($rec_dump);
        }
 
        if ($errors) {
                $log->debug("errors: ", sub { dump( $errors ) } );
 
-               my $mfn = $rec->{'000'}->[0];
+               my $mfn = $rec->{'000'}->[0] || $log->logconfess("record ", dump( $rec ), " doesn't have MFN");
                $self->{errors}->{$mfn} = $errors;
        }
 
@@ -234,6 +235,32 @@ sub validate_errors {
        return $errors;
 }
 
+=head2 reset_errors
+
+Clean all accumulated errors for this input
+
+  $validate->reset_errors;
+
+=cut
+
+sub reset_errors {
+       my $self = shift;
+       delete ($self->{errors});
+}
+
+=head2 all_errors
+
+Return hash with all errors
+
+  print dump( $validate->all_errors );
+
+=cut
+
+sub all_errors {
+       my $self = shift;
+       return $self->{errors};
+}
+
 =head1 AUTHOR
 
 Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>

diff --git a/run.pl b/run.pl
index 0b61092..173bfc0 100755 (executable)
--- a/run.pl
+++ b/run.pl
@@ -406,11 +406,9 @@ while (my ($database, $db_config) = each %{ $config->{databases} }) {
 
 
                                if ($validate) {
-                                       if ( my $errors = $validate->validate_errors( $row ) ) {
-                                               my $dump_record = defined($errors->{dump}->{record});
-                                               $log->error( "MFN $mfn\n",
-                                                       $dump_record ? $input_db->dump : '',
-                                                       "validation errors:\n", dump( $errors )
+                                       if ( my $errors = $validate->validate_errors( $row, $input_db->dump ) ) {
+                                               $log->error( "MFN $mfn validation error:\n",
+                                                       dump( $errors )
                                                );
                                        }
                                }
@@ -465,7 +463,7 @@ while (my ($database, $db_config) = each %{ $config->{databases} }) {
                                $total_rows++;
                        }
 
-                       $log->info("validation errors:\n", dump( $validate->{errors} ) ) if ($validate && defined($validate->{errors}));
+                       $log->info("validation errors:\n", dump( $validate->all_errors ) ) if ($validate && defined($validate->all_errors));
 
                        $log->info("statistics of fields usage:\n", $input_db->stats) if ($stats);
 

diff --git a/t/1-validate.t b/t/1-validate.t
index df43161..f01881d 100755 (executable)
--- a/t/1-validate.t
+++ b/t/1-validate.t
@@ -1,11 +1,11 @@
 #!/usr/bin/perl -w
 
 use strict;
-use Test::More tests => 16;
+use Test::More tests => 29;
 use Test::Exception;
 use blib;
 
-use Data::Dumper;
+use Data::Dump qw/dump/;
 use Cwd qw/abs_path/;
 
 BEGIN {
@@ -34,36 +34,65 @@ is_deeply( $v->{rules}, {
 
 throws_ok { $v->validate_errors() } qr/rec/, "validate_rec need rec";
 
-ok($v->validate_errors({ '900' => 'foo' }), '900 garbage input');
+sub test_v {
+       my $row = shift || die "no row?";
 
-ok(! $v->validate_errors({
+       my $d = dump( $row );
+
+       $row->{'000'} = [ 42 ];
+
+       $v->reset_errors;
+       my $e = $v->validate_errors( $row );
+
+       diag "validate $d\n",dump($e) if ($debug);
+
+       if (@_) {
+               my $tmp = $e;
+               while (@_) {
+                       my $k = shift @_;
+                       ok($tmp = $tmp->{$k}, "found $k");
+               }
+               diag "additional message: $tmp" if ($tmp);
+       } else {
+               ok(! $e, "validated $d");
+               diag "expected error: ", dump($e) if($e);
+       }
+
+}
+
+test_v({
+       '900' => 'foo'
+}, qw/field 900 not_repeatable/);
+
+test_v({
        '900' => [ qw/foo bar baz/ ]
-}), '900 no sf');
+});
 
-ok($v->validate_errors({
+test_v({
        '901' => [ qw/foo bar baz/ ]
-}), '901 no sf');
+}, qw/field 901 missing_subfield/);
 
-ok(! $v->validate_errors({
+test_v({
        '901' => [ { 'a' => 42 } ]
-}), '901^a');
+});
 
-ok($v->validate_errors({
+test_v({
        '901' => [ { 'b' => 42 } ]
-}), '901^b');
+}, qw/field 901 subfield b/);
 
-ok(! $v->validate_errors({
+test_v({
        '902' => [ { 'b' => 1 }, { 'c' => 2 } ]
-}), '902^b 902^c');
+});
 
-ok($v->validate_errors({
+test_v({
        '902' => [ { 'a' => 0 }, { 'b' => 1 }, { 'c' => 2 } ]
-}), '902^a 902^b 902^c');
+}, qw/field 902 subfield a/);
 
-ok(! $v->validate_errors({
+test_v({
        '903' => [ { 'a' => 0 }, { 'b' => 1 }, { 'c' => 2 } ]
-}), '903^a 903^b 903^c');
+});
 
-ok($v->validate_errors({
+test_v({
        '903' => [ { 'a' => 0 }, { 'b' => 1 }, { 'c' => 2 }, { 'd' => 3 } ]
-}), '903^a 903^b 903^c 903^d');
+}, qw/field 903 subfield d/);
+