chore: tests: use schema builder for columns setup

tests/Function/Aggregate/AvgTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Aggregate\Avg;
 
 it('can aggregate a column by AVG')
     ->expect(new Avg('val'))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('avg(`val`)')
     ->toBePgsql('avg("val")')
     ->toBeSqlite('avg("val")')

tests/Function/Aggregate/CountFilterTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Aggregate\CountFilter;
 
 it('can aggregate a column by COUNT with a filter')
     ->expect(new CountFilter(new Expression('val = 1')))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('sum(val = 1)')
     ->toBePgsql('count(*) filter (where val = 1)')
     ->toBeSqlite('count(*) filter (where val = 1)')

tests/Function/Aggregate/CountTest.php

@@ -3,19 +3,24 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Aggregate\Count;
 
 it('can aggregate a column by COUNT')
     ->expect(new Count('val'))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('count(`val`)')
     ->toBePgsql('count("val")')
     ->toBeSqlite('count("val")')
     ->toBeSqlsrv('count([val])');
 
 it('can aggregate a column by COUNT with DISTINCT')
     ->expect(new Count('val', true))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('count(distinct `val`)')
     ->toBePgsql('count(distinct "val")')
     ->toBeSqlite('count(distinct "val")')

tests/Function/Aggregate/MaxTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Aggregate\Max;
 
 it('can aggregate a column by MAX')
     ->expect(new Max('val'))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('max(`val`)')
     ->toBePgsql('max("val")')
     ->toBeSqlite('max("val")')

tests/Function/Aggregate/MinTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Aggregate\Min;
 
 it('can aggregate a column by MIN')
     ->expect(new Min('val'))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('min(`val`)')
     ->toBePgsql('min("val")')
     ->toBeSqlite('min("val")')

tests/Function/Aggregate/SumFilterTest.php

@@ -3,19 +3,25 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Aggregate\SumFilter;
 
 it('can aggregate a column by SUM with a filter')
     ->expect(new SumFilter('val1', new Expression('val2 = 1')))
-    ->toBeExecutable(['val1 int', 'val2 int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val1');
+        $table->integer('val2');
+    })
     ->toBeMysql('sum(case when val2 = 1 then `val1` else 0 end)')
     ->toBePgsql('sum("val1") filter (where val2 = 1)')
     ->toBeSqlite('sum("val1") filter (where val2 = 1)')
     ->toBeSqlsrv('sum(case when val2 = 1 then [val1] else 0 end)');
 
 it('can aggregate an expression by SUM with a filter')
     ->expect(new SumFilter(new Expression(1), new Expression('val = 1')))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('sum(case when val = 1 then 1 else 0 end)')
     ->toBePgsql('sum(1) filter (where val = 1)')
     ->toBeSqlite('sum(1) filter (where val = 1)')

tests/Function/Aggregate/SumTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Aggregate\Sum;
 
 it('can aggregate a column by SUM')
     ->expect(new Sum('val'))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('sum(`val`)')
     ->toBePgsql('sum("val")')
     ->toBeSqlite('sum("val")')

tests/Function/Comparison/StrListContainsTest.php

@@ -3,11 +3,15 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Comparison\StrListContains;
 
 it('can check for existence of a column within a column string list')
     ->expect(new StrListContains('haystack', 'needle'))
-    ->toBeExecutable(['haystack varchar(255)', 'needle varchar(255)'], options: [
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->string('haystack');
+        $table->string('needle');
+    }, options: [
         'sqlsrv' => ['position' => 'where'],
     ])
     ->toBeMysql('FIND_IN_SET(`needle`, `haystack`) > 0')
@@ -27,7 +31,9 @@
 
 it('can check for existence of a column within an expression string list')
     ->expect(new StrListContains(new Expression("'a,b,c'"), 'needle'))
-    ->toBeExecutable(['needle varchar(255)'], options: [
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->string('needle');
+    }, options: [
         'sqlsrv' => ['position' => 'where'],
     ])
     ->toBeMysql("FIND_IN_SET(`needle`, 'a,b,c') > 0")
@@ -37,7 +43,9 @@
 
 it('can check for existence of an expression within a column string list')
     ->expect(new StrListContains('haystack', new Expression("'a'")))
-    ->toBeExecutable(['haystack varchar(255)'], options: [
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->string('haystack');
+    }, options: [
         'sqlsrv' => ['position' => 'where'],
     ])
     ->toBeMysql("FIND_IN_SET('a', `haystack`) > 0")

tests/Function/Conditional/CoalesceTest.php

@@ -3,11 +3,16 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Conditional\Coalesce;
 
 it('can combine multiple columns')
     ->expect(new Coalesce(['val1', 'val2', 'val3']))
-    ->toBeExecutable(['val1 int', 'val2 int', 'val3 int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val1');
+        $table->integer('val2');
+        $table->integer('val3');
+    })
     ->toBeMysql('coalesce(`val1`, `val2`, `val3`)')
     ->toBePgsql('coalesce("val1", "val2", "val3")')
     ->toBeSqlite('coalesce("val1", "val2", "val3")')
@@ -23,7 +28,10 @@
 
 it('can combine multiple columns and expressions')
     ->expect(new Coalesce(['val1', 'val2', new Expression(3)]))
-    ->toBeExecutable(['val1 int', 'val2 int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val1');
+        $table->integer('val2');
+    })
     ->toBeMysql('coalesce(`val1`, `val2`, 3)')
     ->toBePgsql('coalesce("val1", "val2", 3)')
     ->toBeSqlite('coalesce("val1", "val2", 3)')

tests/Function/Conditional/GreatestTest.php

@@ -3,11 +3,16 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Conditional\Greatest;
 
 it('can combine multiple columns')
     ->expect(new Greatest(['val1', 'val2', 'val3']))
-    ->toBeExecutable(['val1 int', 'val2 int', 'val3 int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val1');
+        $table->integer('val2');
+        $table->integer('val3');
+    })
     ->toBeMysql('greatest(`val1`, `val2`, `val3`)')
     ->toBePgsql('greatest("val1", "val2", "val3")')
     ->toBeSqlite('max("val1", "val2", "val3")')
@@ -23,7 +28,10 @@
 
 it('can combine multiple columns and expressions')
     ->expect(new Greatest(['val1', 'val2', new Expression(3)]))
-    ->toBeExecutable(['val1 int', 'val2 int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val1');
+        $table->integer('val2');
+    })
     ->toBeMysql('greatest(`val1`, `val2`, 3)')
     ->toBePgsql('greatest("val1", "val2", 3)')
     ->toBeSqlite('max("val1", "val2", 3)')

tests/Function/Conditional/LeastTest.php

@@ -3,11 +3,16 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\Conditional\Least;
 
 it('can combine multiple columns')
     ->expect(new Least(['val1', 'val2', 'val3']))
-    ->toBeExecutable(['val1 int', 'val2 int', 'val3 int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val1');
+        $table->integer('val2');
+        $table->integer('val3');
+    })
     ->toBeMysql('least(`val1`, `val2`, `val3`)')
     ->toBePgsql('least("val1", "val2", "val3")')
     ->toBeSqlite('min("val1", "val2", "val3")')
@@ -23,7 +28,10 @@
 
 it('can combine multiple columns and expressions')
     ->expect(new Least(['val1', 'val2', new Expression(3)]))
-    ->toBeExecutable(['val1 int', 'val2 int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val1');
+        $table->integer('val2');
+    })
     ->toBeMysql('least(`val1`, `val2`, 3)')
     ->toBePgsql('least("val1", "val2", 3)')
     ->toBeSqlite('min("val1", "val2", 3)')

tests/Function/String/ConcatTest.php

@@ -3,11 +3,16 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\String\Concat;
 
 it('can concat multiple columns')
     ->expect(new Concat(['val1', 'val2', 'val3']))
-    ->toBeExecutable(['val1 varchar(255)', 'val2 varchar(255)', 'val3 varchar(255)'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->string('val1');
+        $table->string('val2');
+        $table->string('val3');
+    })
     ->toBeMysql('(concat(`val1`,`val2`,`val3`))')
     ->toBePgsql('("val1"||"val2"||"val3")')
     ->toBeSqlite('("val1"||"val2"||"val3")')
@@ -23,7 +28,10 @@
 
 it('can concat multiple columns and expressions')
     ->expect(new Concat(['val1', 'val2', new Expression("'c'")]))
-    ->toBeExecutable(['val1 varchar(255)', 'val2 varchar(255)'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->string('val1');
+        $table->string('val2');
+    })
     ->toBeMysql("(concat(`val1`,`val2`,'c'))")
     ->toBePgsql('("val1"||"val2"||\'c\')')
     ->toBeSqlite('("val1"||"val2"||\'c\')')

tests/Function/String/LowerTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\String\Lower;
 
 it('can lowercase a column')
     ->expect(new Lower('val'))
-    ->toBeExecutable(['val varchar(255)'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->string('val');
+    })
     ->toBeMysql('(lower(`val`))')
     ->toBePgsql('lower("val")')
     ->toBeSqlite('(lower("val"))')

tests/Function/String/UpperTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Function\String\Upper;
 
 it('can uppercase a column')
     ->expect(new Upper('val'))
-    ->toBeExecutable(['val varchar(255)'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->string('val');
+    })
     ->toBeMysql('(upper(`val`))')
     ->toBePgsql('upper("val")')
     ->toBeSqlite('(upper("val"))')

tests/Function/Time/TimestampBinTest.php

@@ -3,36 +3,45 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\DB;
 use Tpetry\QueryExpressions\Function\Time\TimestampBin;
 
 it('can bin the time of a column')
     ->expect(new TimestampBin('val', DateInterval::createFromDateString('5 minutes')))
-    ->toBeExecutable(['val timestamp'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->timestamp('val');
+    })
     ->toBeMysql('(from_unixtime(floor((unix_timestamp(`val`)-0)/300)*300+0))')
     ->toBePgsql('to_timestamp(floor((extract(epoch from "val")-0)/300)*300+0)')
     ->toBeSqlite('(datetime((strftime(\'%s\',"val")-0)/300*300+0,\'unixepoch\'))')
     ->toBeSqlsrv('dateadd(s,(datediff(s,\'1970-01-01\',[val])-0)/300*300+0,\'1970-01-01\')');
 
 it('can bin the time of an expression')
     ->expect(new TimestampBin(new Expression('current_timestamp'), DateInterval::createFromDateString('1 minute')))
-    ->toBeExecutable(['val timestamp'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->timestamp('val');
+    })
     ->toBeMysql('(from_unixtime(floor((unix_timestamp(current_timestamp)-0)/60)*60+0))')
     ->toBePgsql('to_timestamp(floor((extract(epoch from current_timestamp)-0)/60)*60+0)')
     ->toBeSqlite('(datetime((strftime(\'%s\',current_timestamp)-0)/60*60+0,\'unixepoch\'))')
     ->toBeSqlsrv('dateadd(s,(datediff(s,\'1970-01-01\',current_timestamp)-0)/60*60+0,\'1970-01-01\')');
 
 it('can bin the time of a column with an origin')
     ->expect(new TimestampBin('val', DateInterval::createFromDateString('90 seconds'), DateTime::createFromFormat('Y-m-d H:i:s', '2022-02-02 22:22:22')))
-    ->toBeExecutable(['val timestamp'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->timestamp('val');
+    })
     ->toBeMysql('(from_unixtime(floor((unix_timestamp(`val`)-1643840542)/90)*90+1643840542))')
     ->toBePgsql('to_timestamp(floor((extract(epoch from "val")-1643840542)/90)*90+1643840542)')
     ->toBeSqlite('(datetime((strftime(\'%s\',"val")-1643840542)/90*90+1643840542,\'unixepoch\'))')
     ->toBeSqlsrv('dateadd(s,(datediff(s,\'1970-01-01\',[val])-1643840542)/90*90+1643840542,\'1970-01-01\')');
 
 it('can bin the time of an expression with an origin')
     ->expect(new TimestampBin(new Expression('current_timestamp'), DateInterval::createFromDateString('1 hour'), DateTime::createFromFormat('Y-m-d H:i:s', '2000-01-01 00:00:00')))
-    ->toBeExecutable(['val timestamp'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->timestamp('val');
+    })
     ->toBeMysql('(from_unixtime(floor((unix_timestamp(current_timestamp)-946684800)/3600)*3600+946684800))')
     ->toBePgsql('to_timestamp(floor((extract(epoch from current_timestamp)-946684800)/3600)*3600+946684800)')
     ->toBeSqlite('(datetime((strftime(\'%s\',current_timestamp)-946684800)/3600*3600+946684800,\'unixepoch\'))')

tests/Language/AliasTest.php

@@ -3,11 +3,14 @@
 declare(strict_types=1);
 
 use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
 use Tpetry\QueryExpressions\Language\Alias;
 
 it('can alias a column')
     ->expect(new Alias('val', 'value'))
-    ->toBeExecutable(['val int'])
+    ->toBeExecutable(function (Blueprint $table) {
+        $table->integer('val');
+    })
     ->toBeMysql('`val` as `value`')
     ->toBePgsql('"val" as "value"')
     ->toBeSqlite('"val" as "value"')