Remove SQL::Abstract::AST::Compat and put all the code into SQL::Abstract::Compat...

[dbsrgits/SQL-Abstract-2.0-ish.git] / t / compat / ast / 01.t

diff --git a/t/compat/ast/01.t b/t/compat/ast/01.t
index ff21dc0..55e49c7 100644 (file)
--- a/t/compat/ast/01.t
+++ b/t/compat/ast/01.t
@@ -1,42 +1,29 @@
 use strict;
 use warnings;
 
-use SQL::Abstract::AST::Compat;
+use SQL::Abstract::Compat;
 
-use Test::More tests => 8;
+use Test::More tests => 12;
 use Test::Differences;
 
-ok(my $visitor = SQL::Abstract::AST::Compat->new);
+ok(my $visitor = SQL::Abstract::Compat->new);
+
 
 my $foo_id = { -type => 'name', args => [qw/foo/] };
 my $bar_id = { -type => 'name', args => [qw/bar/] };
 
-my $foo_eq_1 = {
-  -type => 'expr',
-  op => '==',
-  args => [
-    $foo_id,
-    { -type => 'value', value => 1 }
-  ]
-};
+my $foo_eq_1 = field_op_value($foo_id, '==', 1);
+my $bar_eq_str = field_op_value($bar_id, '==', 'some str');
 
 eq_or_diff
-  $visitor->generate({ foo => 1 }),
+  $visitor->recurse_where({ foo => 1 }),
   $foo_eq_1,
   "Single value hash";
 
 
-my $bar_eq_str = {
-  -type => 'expr',
-  op => '==',
-  args => [
-    $bar_id,
-    { -type => 'value', value => 'some str' }
-  ]
-};
 
 eq_or_diff
-  $visitor->generate({ foo => 1, bar => 'some str' }),
+  $visitor->recurse_where({ foo => 1, bar => 'some str' }),
   { -type => 'expr',
     op => 'and',
     args => [
@@ -47,7 +34,7 @@ eq_or_diff
   "two keys in hash";
 
 eq_or_diff
-  $visitor->generate({ -or => { foo => 1, bar => 'some str' } }),
+  $visitor->recurse_where({ -or => { foo => 1, bar => 'some str' } }),
   { -type => 'expr',
     op => 'or',
     args => [
@@ -59,7 +46,7 @@ eq_or_diff
 
 
 eq_or_diff
-  $visitor->generate([ -and => { foo => 1, bar => 'some str' } ]),
+  $visitor->recurse_where([ -and => { foo => 1, bar => 'some str' } ]),
   { -type => 'expr',
     op => 'and',
     args => [
@@ -71,7 +58,7 @@ eq_or_diff
 
 
 eq_or_diff
-  $visitor->generate([ -and => { foo => 1, bar => 'some str' }, { foo => 1} ]),
+  $visitor->recurse_where([ -and => { foo => 1, bar => 'some str' }, { foo => 1} ]),
   { -type => 'expr',
     op => 'or',
     args => [
@@ -88,30 +75,109 @@ eq_or_diff
   "-and as first element of array + hash";
 
 eq_or_diff
-  $visitor->generate({ foo => { '!=' => 'bar' } }),
+  $visitor->recurse_where({ foo => { '!=' => 'bar' } }),
+  field_op_value($foo_id, '!=', 'bar'),
+  "foo => { '!=' => 'bar' }";
+
+eq_or_diff
+  $visitor->recurse_where({ foo => [ 1, 'bar' ] }),
+  { -type => 'expr',
+    op => 'or',
+    args => [
+      $foo_eq_1,
+      field_op_value($foo_id, '==', 'bar'),
+    ],
+  },
+  "foo => [ 1, 'bar' ]";
+
+eq_or_diff
+  $visitor->recurse_where({ foo => { -in => [ 1, 'bar' ] } }),
   { -type => 'expr',
-    op => '!=',
+    op => 'in',
     args => [
       $foo_id,
+      { -type => 'value', value => 1 },
       { -type => 'value', value => 'bar' },
     ]
   },
-  "foo => { '!=' => 'bar' }";
+  "foo => { -in => [ 1, 'bar' ] }";
 
 eq_or_diff
-  $visitor->generate({ foo => [ 1, 'bar' ] }),
+  $visitor->recurse_where({ foo => { -not_in => [ 1, 'bar' ] } }),
   { -type => 'expr',
-    op => 'or',
+    op => 'not_in',
     args => [
-      $foo_eq_1,
+      $foo_id,
+      { -type => 'value', value => 1 },
+      { -type => 'value', value => 'bar' },
+    ]
+  },
+  "foo => { -not_in => [ 1, 'bar' ] }";
+
+eq_or_diff
+  $visitor->recurse_where({ foo => { -in => [ ] } }),
+  { -type => 'expr',
+    op => 'in',
+    args => [
+      $foo_id,
+    ]
+  },
+  "foo => { -in => [ ] }";
+
+my $worker_eq = sub {
+  return { 
+    -type => 'expr',
+    op => '==',
+    args => [
+      { -type => 'name', args => ['worker'] },
+      { -type => 'value', value => $_[0] },
+    ],
+  }
+};
+eq_or_diff
+  $visitor->recurse_where( {
+    requestor => 'inna',
+    worker => ['nwiger', 'rcwe', 'sfz'],
+    status => { '!=', 'completed' }
+  } ),
+  { -type => 'expr',
+    op => 'and',
+    args => [
+      field_op_value(qw/status != completed/), 
       { -type => 'expr',
-        op => '==',
+        op => 'or',
         args => [
-          $foo_id,
-          { -type => 'value', value => 'bar' },
+          field_op_value(qw/worker == nwiger/), 
+          field_op_value(qw/worker == rcwe/), 
+          field_op_value(qw/worker == sfz/), 
         ]
       },
-    ],
+      field_op_value(qw/requestor == inna/),
+    ]
   },
-  "foo => [ 1, 'bar' ]";
+  "complex expr #1";
+
+
 
+sub field_op_value {
+  my ($field, $op, $value) = @_;
+
+  $field = ref $field eq 'HASH'
+         ? $field
+         : ref $field eq 'ARRAY' 
+         ? { -type => 'name', args => $field } 
+         : { -type => 'name', args => [$field] };
+
+  $value = ref $value eq 'HASH'
+         ? $value
+         : { -type => 'value', value => $value };
+
+  return {
+    -type => 'expr',
+    op => $op,
+    args => [
+      $field,
+      $value
+    ]
+  };
+}