Add support for migrations

imanghafoori1 · Aug 8, 2023 · 693ee38 · 693ee38
1 parent 82b357f
commit 693ee38
Show file tree

Hide file tree

Showing 6 changed files with 349 additions and 13 deletions.
diff --git a/composer.json b/composer.json
@@ -21,7 +21,7 @@
     },
     "require-dev": {
         "phpunit/phpunit": "^7.5.20|^8.5.28|^9.5",
-        "symfony/var-dumper" : "*"
+        "symfony/var-dumper" : "3.*|4.*|5.*"
     },
     "autoload": {
         "psr-4": {

diff --git a/src/FakeConnection.php b/src/FakeConnection.php
@@ -5,8 +5,6 @@
 use Closure;
 use Illuminate\Database\Connection;
 use Illuminate\Database\ConnectionInterface;
-use Illuminate\Database\Schema\Builder as SchemaBuilder;
-use Illuminate\Database\Schema\Grammars\MySqlGrammar as SchemaGrammar;
 use Illuminate\Support\Arr;
 
 class FakeConnection extends Connection implements ConnectionInterface
@@ -27,6 +25,16 @@ public function transaction(Closure $callback, $attempts = 1)
         return $callback();
     }
 
+    public function getSchemaBuilder()
+    {
+        return new FakeSchemaBuilder($this);
+    }
+
+    public function getSchemaGrammar()
+    {
+        return $this->getDefaultSchemaGrammar();
+    }
+
     public function query()
     {
         return new FakeQueryBuilder(
@@ -46,6 +54,14 @@ public function statement($query, $bindings = [])
         } else {
 
         }
+        if (FakeSchemaGrammar::$query && is_string($query)) {
+            $payload = array_shift(FakeSchemaGrammar::$query);
+            $query = [
+                'sql' => $query,
+                'args' => $payload['args'] ?? null,
+                'type' => $payload['type'],
+            ];
+        }
 
         if (is_string($query)) {
             return parent::statement($query);
@@ -59,8 +75,37 @@ public function statement($query, $bindings = [])
             }
 
             if ($query['type'] === 'createTable') {
-                [$blueprint, $fluent, $connection] = $query['args'];
-                FakeDB::createTable($blueprint, $fluent, $connection);
+                FakeDB::createTable($query['args']);
+            } elseif ($query['type'] === 'index') {
+            } elseif ($query['type'] === 'primary') {
+            } elseif ($query['type'] === 'autoIncrementStartValue') {
+            } elseif ($query['type'] === 'change') {
+            } elseif ($query['type'] === 'enableForeignKeyConstraints') {
+            } elseif ($query['type'] === 'disableForeignKeyConstraints') {
+            } elseif ($query['type'] === 'dropColumn') {
+                [$blueprint, $fluent] = $query['args'];
+                foreach ($blueprint->getCommands() as $fluentCommand) {
+                    $cols = $fluentCommand->getAttributes()['columns'];
+                    FakeDB::dropColumns($blueprint->getTable(), $cols);
+                }
+            } elseif ($query['type'] === 'drop') {
+                [$blueprint, $fluent] = $query['args'];
+                FakeDB::dropTable($blueprint->getTable());
+            } elseif ($query['type'] === 'dropAllTables') {
+                FakeDB::dropAllTables();
+            } elseif ($query['type'] === 'dropIfExists') {
+                [$blueprint, $fluent] = $query['args'];
+                FakeDB::dropTable($blueprint->getTable());
+            } elseif ($query['type'] === 'rename') {
+                [$blueprint, $fluent] = $query['args'];
+
+                /**
+                 * @var $blueprint \Illuminate\Database\Schema\Blueprint
+                 */
+                $from = $blueprint->getTable();
+                $to = $blueprint->getCommands()[0]->getAttributes()['to'];
+
+                FakeDB::renameTable($from, $to);
             } else {
                 return (bool) FakeDB::insertGetId($query['value'], $query['builder']->from);
             }

diff --git a/src/FakeDB.php b/src/FakeDB.php
@@ -17,6 +17,8 @@ class FakeDB
 
     public static $fakeRows = [];
 
+    public static $schema = [];
+
     public static $changedModels = [];
 
     public static $tables = [];
@@ -37,12 +39,25 @@ public static function getLatestRow($table)
         return $row;
     }
 
-    public static function createTable($blueprint, $fluent, $connection)
+    public static function createTable($args)
     {
         /**
          * @var $blueprint \Illuminate\Database\Schema\Blueprint
          */
-        $columns = $blueprint->getColumns();
+        [$blueprint, $fluent, $connection] = $args;
+        $table = $blueprint->getTable();
+        self::$schema[$table]['columns'] = $columns = $blueprint->getColumns();
+
+        foreach ($columns as $column) {
+            /**
+             * @var $column \Illuminate\Database\Schema\ColumnDefinition
+             */
+            $column = $column->getAttributes();
+            if ($column['autoIncrement'] ?? null) {
+                self::$schema[$table]['primaryKey'] = $column['name'];
+                break;
+            }
+        }
     }
 
     public static function table($table)
@@ -579,11 +594,61 @@ public static function exec($query)
         return self::$type($query);
     }
 
+    public static function columnListing($query)
+    {
+        $dbName = $query['bindings'][0];
+        $table = $query['bindings'][1];
+
+        $cols = [];
+        foreach (self::$schema[$table]['columns'] as $column) {
+            /**
+             * @var \Illuminate\Database\Schema\ColumnDefinition $column
+             */
+            $cols[] = $column->getAttributes()['name'];
+        }
+
+        return $cols;
+    }
+
+    public static function dropColumns($table, $cols)
+    {
+        foreach (self::$schema[$table]['columns'] as $i => $column) {
+            /**
+             * @var \Illuminate\Database\Schema\ColumnDefinition $column
+             */
+            if (in_array($column->getAttributes()['name'], $cols)) {
+                unset(self::$schema[$table]['columns'][$i]);
+            }
+        }
+    }
+
     public static function tableExists($query)
     {
-        $table = $query['bindings'][0];
+        $dbName = $query['bindings'][0];
+        $table = $query['bindings'][1];
+
+        return isset(self::$schema[$table]) ? [1] : [];
+    }
 
-        return isset(self::$tables[$table]) ? [] : [1];
+    public static function getAllTables()
+    {
+        return array_keys(self::$schema);
+    }
+
+    public static function dropTable($table)
+    {
+        unset(self::$schema[$table]);
+    }
+
+    public static function renameTable($from, $to)
+    {
+        self::$schema[$to] = self::$schema[$from];
+        unset(self::$schema[$from]);
+    }
+
+    public static function dropAllTables()
+    {
+        self::$schema = [];
     }
 
     public static function exists($query)

diff --git a/src/FakeSchemaBuilder.php b/src/FakeSchemaBuilder.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Imanghafoori\EloquentMockery;
+
+use Illuminate\Database\Schema\MySqlBuilder;
+
+class FakeSchemaBuilder extends MySqlBuilder
+{
+    //
+}
diff --git a/src/FakeSchemaGrammar.php b/src/FakeSchemaGrammar.php
@@ -9,15 +9,137 @@
 
 class FakeSchemaGrammar extends SchemaGrammar
 {
+    public static $query = [];
+
     public function compileCreate(Blueprint $blueprint, Fluent $command, Connection $connection)
+    {
+        self::keepData('createTable', [$blueprint, $command, $connection]);
+
+        return parent::compileCreate($blueprint, $command, $connection);
+    }
+
+    public function compileAdd(Blueprint $blueprint, Fluent $command)
+    {
+        self::keepData('add', [$blueprint, $command]);
+
+        return parent::compileAdd($blueprint, $command);
+    }
+
+    public function compileChange(Blueprint $blueprint, Fluent $command, Connection $connection)
+    {
+        self::keepData('change', [$blueprint, $command, $connection]);
+
+        return parent::compileChange($blueprint, $command, $connection);
+    }
+
+    public function compileIndex(Blueprint $blueprint, Fluent $command)
+    {
+        self::keepData('index', [$blueprint, $command]);
+
+        return parent::compileIndex($blueprint, $command);
+    }
+
+    public function compileKey(Blueprint $blueprint, Fluent $command, $type)
+    {
+
+    }
+
+    public function compileRenameIndex(Blueprint $blueprint, Fluent $command)
+    {
+
+    }
+
+    public function compileForeign(Blueprint $blueprint, Fluent $command)
+    {
+
+    }
+
+    public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)
+    {
+        //self::keepData('renameColumn', [$blueprint, $command, $connection]);
+
+        //return parent::compileRenameColumn($blueprint, $command);
+    }
+
+    public function compileUnique(Blueprint $blueprint, Fluent $command)
+    {
+
+    }
+
+    public function compileRename(Blueprint $blueprint, Fluent $command)
+    {
+        self::keepData('rename', [$blueprint, $command]);
+
+        return parent::compileRename($blueprint, $command);
+    }
+
+    public function compileDrop(Blueprint $blueprint, Fluent $command)
+    {
+        self::keepData('drop', [$blueprint, $command]);
+
+        return parent::compileDrop($blueprint, $command);
+    }
+
+    public function compileDropIfExists(Blueprint $blueprint, Fluent $command)
+    {
+        self::keepData('dropIfExists', [$blueprint, $command]);
+
+        return parent::compileDropIfExists($blueprint, $command);
+    }
+
+    public function compileColumnListing()
+    {
+        return $this->stringy([
+            'type' => 'columnListing',
+            'sql' => parent::compileColumnListing(),
+        ]);
+
+        return parent::compileColumnListing();
+    }
+
+    public function compileGetAllTables()
     {
         return $this->stringy([
-            'args' => [$blueprint, $command, $connection],
-            'type' => 'createTable',
-            'sql' => parent::compileCreate($blueprint, $command, $connection),
+            'type' => 'getAllTables',
+            'sql' => parent::compileGetAllTables(),
         ]);
     }
 
+    public function compileDropColumn(Blueprint $blueprint, Fluent $command)
+    {
+        self::keepData('dropColumn', [$blueprint, $command]);
+
+        return parent::compileDropColumn($blueprint, $command);
+    }
+
+    public function compileEnableForeignKeyConstraints()
+    {
+        self::keepData('enableForeignKeyConstraints');
+
+        return parent::compileEnableForeignKeyConstraints();
+    }
+
+    public function compileDisableForeignKeyConstraints()
+    {
+        self::keepData('disableForeignKeyConstraints');
+
+        return parent::compileDisableForeignKeyConstraints();
+    }
+
+    public function compilePrimary(Blueprint $blueprint, Fluent $command)
+    {
+        self::keepData('primary', [$blueprint, $command]);
+
+        return parent::compilePrimary($blueprint, $command);
+    }
+
+    public function compileDropAllTables($tables)
+    {
+        self::keepData('dropAllTables', $tables);
+
+        return parent::compileDropAllTables($tables);
+    }
+
     public function compileTableExists()
     {
         return $this->stringy([
@@ -43,4 +165,12 @@ public function __toString()
             }
         };
     }
-}
+
+    private static function keepData(string $type, array $args = [])
+    {
+        self::$query[] = [
+            'type' => $type,
+            'args' => $args,
+        ];
+    }
+}