X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=scpubgit%2FQ-Branch.git;a=blobdiff_plain;f=lib%2FSQL%2FAbstract%2FTest.pm;h=e163f2c5987a0758e96bce06276e752b45f96d83;hp=1ae1a361f3d1a59dbaf925b309a98f64c1ec4bef;hb=cf5b7ab163f8ac123ebc9bb1156e79646cd5bd2f;hpb=0769ac0e4022d40ded0dff13abe292d4867c9d09 diff --git a/lib/SQL/Abstract/Test.pm b/lib/SQL/Abstract/Test.pm index 1ae1a36..e163f2c 100644 --- a/lib/SQL/Abstract/Test.pm +++ b/lib/SQL/Abstract/Test.pm @@ -2,33 +2,86 @@ package SQL::Abstract::Test; # see doc at end of file use strict; use warnings; -use base qw/Test::Builder::Module Exporter/; -use Data::Dumper; +use base qw(Test::Builder::Module Exporter); use Test::Builder; +use Test::Deep (); use SQL::Abstract::Tree; -our @EXPORT_OK = qw/&is_same_sql_bind &is_same_sql &is_same_bind - &eq_sql_bind &eq_sql &eq_bind - $case_sensitive $sql_differ/; +{ + my $class; + if ($class = $ENV{SQL_ABSTRACT_TEST_AGAINST}) { + my $mod = join('/', split '::', $class).".pm"; + require $mod; + eval qq{sub SQL::Abstract () { "\Q${class}\E" }; 1} + or die "Failed to create const sub for ${class}: $@"; + } + if ($ENV{SQL_ABSTRACT_TEST_EXPAND_STABILITY}) { + $class ||= do { require SQL::Abstract; 'SQL::Abstract' }; + my $orig = $class->can('expand_expr'); + require Data::Dumper::Concise; + my $wrapped = sub { + my ($self, @args) = @_; + my $e1 = $self->$orig(@args); + return $e1 if our $Stab_Check_Rec; + local $Stab_Check_Rec = 1; + my $e2 = $self->$orig($e1); + my ($d1, $d2) = map Data::Dumper::Concise::Dumper($_), $e1, $e2; + (our $tb)->is_eq( + $d2, $d1, + 'expand_expr stability ok' + ) or do { + require Path::Tiny; + Path::Tiny->new('e1')->spew($d1); + Path::Tiny->new('e2')->spew($d2); + system('diff -u e1 e2 1>&2'); + die "Differences between e1 and e2, bailing out"; + }; + return $e1; + }; + no strict 'refs'; no warnings 'redefine'; + *{"${class}::expand_expr"} = $wrapped; + } +} + +our @EXPORT_OK = qw( + is_same_sql_bind is_same_sql is_same_bind + eq_sql_bind eq_sql eq_bind dumper diag_where + $case_sensitive $sql_differ +); my $sqlat = SQL::Abstract::Tree->new; our $case_sensitive = 0; our $parenthesis_significant = 0; +our $order_by_asc_significant = 0; + our $sql_differ; # keeps track of differing portion between SQLs our $tb = __PACKAGE__->builder; -# All of these keywords allow their parameters to be specified with or without parenthesis without changing the semantics -my @unrollable_ops = ( - 'ON', - 'WHERE', - 'GROUP \s+ BY', - 'HAVING', - 'ORDER \s+ BY', -); +sub _unpack_arrayrefref { + + my @args; + for (1,2) { + my $chunk = shift @_; + + if (ref $chunk eq 'REF' and ref $$chunk eq 'ARRAY') { + my ($sql, @bind) = @$$chunk; + push @args, ($sql, \@bind); + } + else { + push @args, $chunk, shift @_; + } + + } + + # maybe $msg and ... stuff + push @args, @_; + + @args; +} sub is_same_sql_bind { - my ($sql1, $bind_ref1, $sql2, $bind_ref2, $msg) = @_; + my ($sql1, $bind_ref1, $sql2, $bind_ref2, $msg) = &_unpack_arrayrefref; # compare my $same_sql = eq_sql($sql1, $sql2); @@ -53,7 +106,7 @@ sub is_same_sql { my ($sql1, $sql2, $msg) = @_; # compare - my $same_sql = eq_sql($sql1, $sql2); + my $same_sql = eq_sql($sql1, $sql2); # call Test::Builder::ok my $ret = $tb->ok($same_sql, $msg); @@ -85,40 +138,52 @@ sub is_same_bind { return $ret; } +sub dumper { + # FIXME + # if we save the instance, we will end up with $VARx references + # no time to figure out how to avoid this (Deepcopy is *not* an option) + require Data::Dumper; + Data::Dumper->new([])->Terse(1)->Indent(1)->Useqq(1)->Deparse(1)->Quotekeys(0)->Sortkeys(1)->Maxdepth(0) + ->Values([@_])->Dump; +} + +sub diag_where{ + $tb->diag("Search term:\n" . &dumper); +} + sub _sql_differ_diag { - my ($sql1, $sql2) = @_; + my $sql1 = shift || ''; + my $sql2 = shift || ''; + + if (my $profile = $ENV{SQL_ABSTRACT_TEST_TREE_PROFILE}) { + my $sqlat = SQL::Abstract::Tree->new(profile => $profile); + $_ = $sqlat->format($_) for ($sql1, $sql2); + } - $tb->diag("SQL expressions differ\n" - ." got: $sql1\n" - ."expected: $sql2\n" - ."differing in :\n$sql_differ\n" - ); + $tb->${\($tb->in_todo ? 'note' : 'diag')} ( + "SQL expressions differ\n" + ." got: $sql1\n" + ."want: $sql2\n" + ."\nmismatch around\n$sql_differ\n" + ); } sub _bind_differ_diag { my ($bind_ref1, $bind_ref2) = @_; - $tb->diag("BIND values differ\n" - ." got: " . Dumper($bind_ref1) - ."expected: " . Dumper($bind_ref2) - ); + $tb->${\($tb->in_todo ? 'note' : 'diag')} ( + "BIND values differ " . dumper({ got => $bind_ref1, want => $bind_ref2 }) + ); } sub eq_sql_bind { - my ($sql1, $bind_ref1, $sql2, $bind_ref2) = @_; + my ($sql1, $bind_ref1, $sql2, $bind_ref2) = &_unpack_arrayrefref; return eq_sql($sql1, $sql2) && eq_bind($bind_ref1, $bind_ref2); } -sub eq_bind { - my ($bind_ref1, $bind_ref2) = @_; - - local $Data::Dumper::Useqq = 1; - local $Data::Dumper::Sortkeys = 1; - - return Dumper($bind_ref1) eq Dumper($bind_ref2); -} +sub eq_bind { goto &Test::Deep::eq_deeply }; sub eq_sql { my ($sql1, $sql2) = @_; @@ -127,6 +192,7 @@ sub eq_sql { my $tree1 = $sqlat->parse($sql1); my $tree2 = $sqlat->parse($sql2); + undef $sql_differ; return 1 if _eq_sql($tree1, $tree2); } @@ -134,167 +200,88 @@ sub _eq_sql { my ($left, $right) = @_; # one is defined the other not - if ( (defined $left) xor (defined $right) ) { + if ((defined $left) xor (defined $right)) { + $sql_differ = sprintf ("[%s] != [%s]\n", map { defined $_ ? $sqlat->unparse($_) : 'N/A' } ($left, $right) ); return 0; } + # one is undefined, then so is the other elsif (not defined $left) { return 1; } - # different amount of elements - elsif (@$left != @$right) { - $sql_differ = sprintf ("left: %s\nright: %s\n", map { $sqlat->unparse ($_) } ($left, $right) ); - return 0; - } - # one is empty - so is the other - elsif (@$left == 0) { + + # both are empty + elsif (@$left == 0 and @$right == 0) { return 1; } + + # one is empty + if (@$left == 0 or @$right == 0) { + $sql_differ = sprintf ("left: %s\nright: %s\n", map { @$_ ? $sqlat->unparse($_) : 'N/A'} ($left, $right) ); + return 0; + } + # one is a list, the other is an op with a list elsif (ref $left->[0] xor ref $right->[0]) { - $sql_differ = sprintf ("left: %s\nright: %s\n", map { $sqlat->unparse ($_) } ($left, $right) ); + $sql_differ = sprintf ("[%s] != [%s]\nleft: %s\nright: %s\n", map + { ref $_ ? $sqlat->unparse($_) : $_ } + ($left->[0], $right->[0], $left, $right) + ); return 0; } - # one is a list, so is the other + + # both are lists elsif (ref $left->[0]) { for (my $i = 0; $i <= $#$left or $i <= $#$right; $i++ ) { - return 0 if (not _eq_sql ($left->[$i], $right->[$i]) ); + if (not _eq_sql ($left->[$i], $right->[$i]) ) { + if (! $sql_differ or $sql_differ !~ /left\:\s .+ right:\s/xs) { + $sql_differ ||= ''; + $sql_differ .= "\n" unless $sql_differ =~ /\n\z/; + $sql_differ .= sprintf ("left: %s\nright: %s\n", map { $sqlat->unparse($_) } ($left, $right) ); + } + return 0; + } } return 1; } - # both are an op-list combo + + # both are ops else { # unroll parenthesis if possible/allowed - _parenthesis_unroll ($_) for ($left, $right); + unless ($parenthesis_significant) { + $sqlat->_parenthesis_unroll($_) for $left, $right; + } + + # unroll ASC order by's + unless ($order_by_asc_significant) { + $sqlat->_strip_asc_from_order_by($_) for $left, $right; + } - # if operators are different - if ( $left->[0] ne $right->[0] ) { + if ($left->[0] ne $right->[0]) { $sql_differ = sprintf "OP [$left->[0]] != [$right->[0]] in\nleft: %s\nright: %s\n", $sqlat->unparse($left), - $sqlat->unparse($right); + $sqlat->unparse($right) + ; return 0; } - # elsif operators are identical, compare operands - else { - if ($left->[0] eq 'LITERAL' ) { # unary - (my $l = " $left->[1][0] " ) =~ s/\s+/ /g; - (my $r = " $right->[1][0] ") =~ s/\s+/ /g; - my $eq = $case_sensitive ? $l eq $r : uc($l) eq uc($r); - $sql_differ = "[$l] != [$r]\n" if not $eq; - return $eq; - } - else { - my $eq = _eq_sql($left->[1], $right->[1]); - $sql_differ ||= sprintf ("left: %s\nright: %s\n", map { $sqlat->unparse ($_) } ($left, $right) ) if not $eq; - return $eq; - } - } - } -} - -sub _parenthesis_unroll { - my $ast = shift; - - return if $parenthesis_significant; - return unless (ref $ast and ref $ast->[1]); - - my $changes; - do { - my @children; - $changes = 0; - - for my $child (@{$ast->[1]}) { - # the current node in this loop is *always* a PAREN - if (not ref $child or not $child->[0] eq 'PAREN') { - push @children, $child; - next; - } - # unroll nested parenthesis - while ( @{$child->[1]} && $child->[1][0][0] eq 'PAREN') { - $child = $child->[1][0]; - $changes++; - } - - # if the parenthesis are wrapped around an AND/OR matching the parent AND/OR - open the parenthesis up and merge the list - if ( - ( $ast->[0] eq 'AND' or $ast->[0] eq 'OR') - and - $child->[1][0][0] eq $ast->[0] - ) { - push @children, @{$child->[1][0][1]}; - $changes++; - } - - # if the parent operator explcitly allows it nuke the parenthesis - elsif ( grep { $ast->[0] =~ /^ $_ $/xi } @unrollable_ops ) { - push @children, $child->[1][0]; - $changes++; - } - - # only *ONE* LITERAL element - elsif ( - @{$child->[1]} == 1 && $child->[1][0][0] eq 'LITERAL' - ) { - push @children, $child->[1][0]; - $changes++; - } - - # only one element in the parenthesis which is a binary op - # and has exactly two grandchildren - # the only time when we can *not* unroll this is when both - # the parent and the child are mathops (in which case we'll - # break precedence) or when the child is BETWEEN (special - # case) - elsif ( - @{$child->[1]} == 1 - and - $child->[1][0][0] =~ SQL::Abstract::Tree::_binary_op_re() - and - $child->[1][0][0] ne 'BETWEEN' - and - @{$child->[1][0][1]} == 2 - and - ! ( - $child->[1][0][0] =~ SQL::Abstract::Tree::_math_op_re() - and - $ast->[0] =~ SQL::Abstract::Tree::_math_op_re() - ) - ) { - push @children, $child->[1][0]; - $changes++; - } - - # a function binds tighter than a mathop - see if our ancestor is a - # mathop, and our content is a single non-mathop child with a single - # PAREN grandchild which would indicate mathop ( nonmathop ( ... ) ) - elsif ( - @{$child->[1]} == 1 - and - @{$child->[1][0][1]} == 1 - and - $child->[1][0][1][0][0] eq 'PAREN' - and - $ast->[0] =~ SQL::Abstract::Tree::_math_op_re() - and - $child->[1][0][0] !~ SQL::Abstract::Tree::_math_op_re - ) { - push @children, $child->[1][0]; - $changes++; - } - - - # otherwise no more mucking for this pass - else { - push @children, $child; - } + # literals have a different arg-sig + elsif ($left->[0] eq '-LITERAL') { + (my $l = " $left->[1][0] " ) =~ s/\s+/ /g; + (my $r = " $right->[1][0] ") =~ s/\s+/ /g; + my $eq = $case_sensitive ? $l eq $r : uc($l) eq uc($r); + $sql_differ = "[$l] != [$r]\n" if not $eq; + return $eq; } - $ast->[1] = \@children; - - } while ($changes); - + # if operators are identical, compare operands + else { + my $eq = _eq_sql($left->[1], $right->[1]); + $sql_differ ||= sprintf ("left: %s\nright: %s\n", map { $sqlat->unparse($_) } ($left, $right) ) if not $eq; + return $eq; + } + } } sub parse { $sqlat->parse(@_) } @@ -346,52 +333,83 @@ B : the semantic equivalence handling is pretty limited. A lot of effort goes into distinguishing significant from non-significant parenthesis, including AND/OR operator associativity. Currently this module does not support commutativity and more -intelligent transformations like Morgan laws, etc. +intelligent transformations like L, etc. -For a good overview of what this test framework is capable of refer +For a good overview of what this test framework is currently capable of refer to C =head1 FUNCTIONS =head2 is_same_sql_bind - is_same_sql_bind($given_sql, \@given_bind, - $expected_sql, \@expected_bind, $test_msg); - -Compares given and expected pairs of C<($sql, \@bind)>, and calls -L on the result, with C<$test_msg> as message. If the test -fails, a detailed diagnostic is printed. For clients which use L, -this is the one of the three functions (L, L, -L) that needs to be imported. + is_same_sql_bind( + $given_sql, \@given_bind, + $expected_sql, \@expected_bind, + $test_msg + ); + + is_same_sql_bind( + \[$given_sql, @given_bind], + \[$expected_sql, @expected_bind], + $test_msg + ); + + is_same_sql_bind( + $dbic_rs->as_query + $expected_sql, \@expected_bind, + $test_msg + ); + +Compares given and expected pairs of C<($sql, \@bind)> by unpacking C<@_> +as shown in the examples above and passing the arguments to L and +L. Calls L with the combined result, with +C<$test_msg> as message. +If the test fails, a detailed diagnostic is printed. =head2 is_same_sql - is_same_sql($given_sql, $expected_sql, $test_msg); + is_same_sql( + $given_sql, + $expected_sql, + $test_msg + ); -Compares given and expected SQL statements, and calls L on -the result, with C<$test_msg> as message. If the test fails, a detailed -diagnostic is printed. For clients which use L, this is the one of -the three functions (L, L, L) -that needs to be imported. +Compares given and expected SQL statements via L, and calls +L on the result, with C<$test_msg> as message. +If the test fails, a detailed diagnostic is printed. =head2 is_same_bind - is_same_bind(\@given_bind, \@expected_bind, $test_msg); + is_same_bind( + \@given_bind, + \@expected_bind, + $test_msg + ); -Compares given and expected bind values, and calls L on the -result, with C<$test_msg> as message. If the test fails, a detailed diagnostic -is printed. For clients which use L, this is the one of the three -functions (L, L, L) that needs -to be imported. +Compares given and expected bind values via L, and calls +L on the result, with C<$test_msg> as message. +If the test fails, a detailed diagnostic is printed. =head2 eq_sql_bind - my $is_same = eq_sql_bind($given_sql, \@given_bind, - $expected_sql, \@expected_bind); + my $is_same = eq_sql_bind( + $given_sql, \@given_bind, + $expected_sql, \@expected_bind, + ); -Compares given and expected pairs of C<($sql, \@bind)>. Similar to -L, but it just returns a boolean value and does not print -diagnostics or talk to L. + my $is_same = eq_sql_bind( + \[$given_sql, @given_bind], + \[$expected_sql, @expected_bind], + ); + + my $is_same = eq_sql_bind( + $dbic_rs->as_query + $expected_sql, \@expected_bind, + ); + +Unpacks C<@_> depending on the given arguments and calls L and +L, returning their combined result. =head2 eq_sql @@ -421,7 +439,13 @@ If true, SQL comparisons will be case-sensitive. Default is false; =head2 $parenthesis_significant If true, SQL comparison will preserve and report difference in nested -parenthesis. Useful for testing the C<-nest> modifier. Defaults to false; +parenthesis. Useful while testing C vs C. +Defaults to false; + +=head2 $order_by_asc_significant + +If true SQL comparison will consider C and +C to be different. Default is false; =head2 $sql_differ @@ -429,14 +453,13 @@ When L returns false, the global variable C<$sql_differ> contains the SQL portion where a difference was encountered. - =head1 SEE ALSO L, L, L. =head1 AUTHORS -Laurent Dami, Elaurent.dami AT etat geneve chE +Laurent Dami Norbert Buchmuller