BuilderTest::testItCreateSQLiteUserWithGrants() - Code Metrics - Inspection of "Added sqlite option builder" - flexphp/flex-database - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( 58ca2f...a1a700 )

by Freddie

created 2020-08-21 20:29 UTC

BuilderTest::testItCreateSQLiteUserWithGrants() A

↳ Parent: BuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	6
c	0
b	0
f	0
dl	0
loc	10
rs	10
cc	1
nc	1
nop	0

<?php declare(strict_types=1);
/*
 * This file is part of FlexPHP.
 *
 * (c) Freddie Gar <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace FlexPHP\Database\Tests\Unit;

use FlexPHP\Database\Builder;
use FlexPHP\Database\Exception\DatabaseValidationException;
use FlexPHP\Database\Tests\TestCase;
use FlexPHP\Schema\Schema;
use FlexPHP\Schema\SchemaAttribute;
use FlexPHP\Schema\SchemaInterface;

class BuilderTest extends TestCase
{
    public function testItPlatformErrorThrowException(): void
    {
        $this->expectException(DatabaseValidationException::class);
        $this->expectExceptionMessage('try: MySQL, SQLSrv');

        new Builder('Unknow');
    }

    public function testItDatabaseNameErrorThrowException(): void
    {
        $this->expectException(DatabaseValidationException::class);
        $this->expectExceptionMessage('Database name [_db] invalid');

        $builder = new Builder('MySQL');
        $builder->createDatabase('_db');
    }

    public function testItCreateMySQLDatabase(): void
    {
        $name = 'db';

        $builder = new Builder('MySQL');
        $builder->createDatabase($name);
        $this->assertEquals(<<<T
CREATE DATABASE $name CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
T
, $builder->toSql());
    }

    public function testItCreateSQLSrvDatabase(): void
    {
        $name = 'db';

        $builder = new Builder('SQLSrv');
        $builder->createDatabase($name);
        $this->assertEquals(<<<T
CREATE DATABASE $name COLLATE latin1_general_100_ci_ai_sc;
T
, $builder->toSql());
    }

    public function testItCreateSQLiteDatabase(): void
    {
        $name = 'db';

        $builder = new Builder('SQLite');
        $builder->createDatabase($name);
        $this->assertEquals(<<<T
T
, $builder->toSql());
    }

    public function testItCreateMySQLDatabaseWithUse(): void
    {
        $name = 'db';

        $builder = new Builder('MySQL');
        $builder->createDatabaseWithUse($name);
        $this->assertEquals(<<<T
CREATE DATABASE $name CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

USE $name;
T
, $builder->toSql());
    }

    public function testItCreateSQLSrvDatabaseWithUse(): void
    {
        $name = 'db';

        $builder = new Builder('SQLSrv');
        $builder->createDatabaseWithUse($name);
        $this->assertEquals(<<<T
CREATE DATABASE $name COLLATE latin1_general_100_ci_ai_sc;
T
, $builder->toSql());
    }

    public function testItCreateSQLiteDatabaseWithUse(): void
    {
        $name = 'db';

        $builder = new Builder('SQLite');
        $builder->createDatabaseWithUse($name);
        $this->assertEquals(<<<T
T
, $builder->toSql());
    }

    public function testItCreateMySQLUser(): void
    {
        $name = 'mysql';
        $password = 'p4sw00rd';

        $builder = new Builder('MySQL');
        $builder->createUser($name, $password);
        $this->assertEquals(<<<T
CREATE USER '$name'@'%' IDENTIFIED BY '$password';
T
, $builder->toSql());
    }

    public function testItCreateSQLSrvUser(): void
    {
        $name = 'sqlsrv';
        $password = 'p4sw00rd';

        $builder = new Builder('SQLSrv');
        $builder->createUser($name, $password);
        $this->assertEquals(<<<T
CREATE LOGIN $name WITH PASSWORD = '$password';
GO
CREATE USER $name FOR LOGIN $name;
GO
T
, $builder->toSql());
    }

    public function testItCreateSQLiteUser(): void
    {
        $name = 'sqlite';
        $password = 'p4sw00rd';

        $builder = new Builder('SQLite');
        $builder->createUser($name, $password);
        $this->assertEquals(<<<T
T
, $builder->toSql());
    }

    public function testItCreateMySQLUserWithGrants(): void
    {
        $name = 'mysql';
        $password = 'p4sw00rd';

        $builder = new Builder('MySQL');
        $builder->createUser($name, $password, 'host', ['ALL PRIVILEGES']);
        $this->assertEquals(<<<T
CREATE USER '$name'@'host' IDENTIFIED BY '$password';

GRANT ALL PRIVILEGES ON *.* TO '$name'@'host';
T
, $builder->toSql());
    }

    public function testItCreateSQLSrvUserWithGrants(): void
    {
        $name = 'sqlsrv';
        $password = 'p4sw00rd';

        $builder = new Builder('SQLSrv');
        $builder->createUser($name, $password, 'host', ['ALL PRIVILEGES']);
        $this->assertEquals(<<<T
CREATE LOGIN $name WITH PASSWORD = '$password';
GO
CREATE USER $name FOR LOGIN $name;
GO

GRANT ALL TO $name;
GO
T
, $builder->toSql());
    }

    public function testItCreateSQLiteUserWithGrants(): void
    {
        $name = 'sqlite';
        $password = 'p4sw00rd';

        $builder = new Builder('SQLite');
        $builder->createUser($name, $password, 'host', ['ALL PRIVILEGES']);
        $this->assertEquals(<<<T
T
, $builder->toSql());
    }

    public function testItCreateMySQLTable(): void
    {
        $builder = new Builder('MySQL');
        $builder->createTable($this->getSchema());
        $this->assertEquals(<<<T
CREATE TABLE bar (
    foo INT DEFAULT NULL COMMENT 'foo'
) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;
T
, $builder->toSql());
    }

    public function testItCreateSQLSrvTable(): void
    {
        $builder = new Builder('SQLSrv');
        $builder->createTable($this->getSchema());
        $this->assertEquals(<<<T
CREATE TABLE bar (
    foo INT
);

EXEC sp_addextendedproperty N'MS_Description', N'foo', N'SCHEMA', 'dbo', N'TABLE', 'bar', N'COLUMN', foo;
T
, $builder->toSql());
    }

    public function testItCreateSQLiteTable(): void
    {
        $builder = new Builder('SQLite');
        $builder->createTable($this->getSchema());
        $this->assertEquals(<<<T
CREATE TABLE bar (
    foo INTEGER DEFAULT NULL
);
T
, $builder->toSql());
    }

    public function testItCreateMySQLComplete(): void
    {
        $dbname = 'complete';
        $username = 'username';
        $password = 'password';
        $host = 'host';
        $schema = new Schema('bar', 'title', [
            new SchemaAttribute('Pk', 'string', 'pk|required'),
            new SchemaAttribute('foo', 'string', 'minlength:10|maxlength:100'),
            new SchemaAttribute('bar', 'integer', 'min:10|max'),
        ]);

        $schemaFk = new Schema('fuz', 'title', [
            new SchemaAttribute('Pk', 'integer', 'pk|ai|required'),
            new SchemaAttribute('barId', 'integer', 'fk:bar'),
        ]);

        $builder = new Builder('MySQL');
        $builder->createDatabaseWithUse($dbname);
        $builder->createUser($username, $password, $host, ['ALL PRIVILEGES'], $dbname);
        $builder->createTable($schema);
        $builder->createTable($schemaFk);

        $this->assertEquals(<<<T
CREATE DATABASE $dbname CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

USE $dbname;

CREATE USER '$username'@'$host' IDENTIFIED BY '$password';

GRANT ALL PRIVILEGES ON $dbname.* TO '$username'@'$host';

CREATE TABLE bar (
    Pk VARCHAR(255) NOT NULL COMMENT 'Pk',
    foo VARCHAR(100) DEFAULT NULL COMMENT 'foo',
    bar INT DEFAULT NULL COMMENT 'bar',
    PRIMARY KEY(Pk)
) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;

CREATE TABLE fuz (
    Pk INT AUTO_INCREMENT NOT NULL COMMENT 'Pk',
    barId INT DEFAULT NULL COMMENT 'barId',
    INDEX IDX_51837B119A5BAE65 (barId),
    PRIMARY KEY(Pk)
) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;

ALTER TABLE fuz ADD CONSTRAINT FK_51837B119A5BAE65 FOREIGN KEY (barId) REFERENCES bar (id);
T
, $builder->toSql());
    }

    public function testItConstraints(): void
    {
        $dbname = 'complete';
        $username = 'username';
        $password = 'password';
        $host = 'host';
        $schema = new Schema('bar', 'title', [
            new SchemaAttribute('Pk', 'string', 'pk|required'),
            new SchemaAttribute('foo', 'string', 'minlength:10|maxlength:100'),
            new SchemaAttribute('bar', 'integer', 'min:10|max'),
        ]);

        $schemaFk = new Schema('fuz', 'title', [
            new SchemaAttribute('Pk', 'integer', 'pk|ai|required'),
            new SchemaAttribute('barId', 'integer', 'fk:bar'),
        ]);

        $schemaFk2 = new Schema('baz', 'title', [
            new SchemaAttribute('Pk', 'integer', 'pk|ai|required'),
            new SchemaAttribute('fuzId', 'integer', 'fk:fuz'),
            new SchemaAttribute('barId', 'integer', 'fk:bar'),
        ]);

        $builder = new Builder('MySQL');
        $builder->createDatabase($dbname);
        $builder->createUser($username, $password, $host);
        $builder->createTable($schema);
        $builder->createTable($schemaFk);
        $builder->createTable($schemaFk2);

        $this->assertEquals(<<<T
CREATE DATABASE $dbname CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

CREATE USER '$username'@'$host' IDENTIFIED BY '$password';

CREATE TABLE bar (
    Pk VARCHAR(255) NOT NULL COMMENT 'Pk',
    foo VARCHAR(100) DEFAULT NULL COMMENT 'foo',
    bar INT DEFAULT NULL COMMENT 'bar',
    PRIMARY KEY(Pk)
) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;

CREATE TABLE fuz (
    Pk INT AUTO_INCREMENT NOT NULL COMMENT 'Pk',
    barId INT DEFAULT NULL COMMENT 'barId',
    INDEX IDX_51837B119A5BAE65 (barId),
    PRIMARY KEY(Pk)
) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;

CREATE TABLE baz (
    Pk INT AUTO_INCREMENT NOT NULL COMMENT 'Pk',
    fuzId INT DEFAULT NULL COMMENT 'fuzId',
    barId INT DEFAULT NULL COMMENT 'barId',
    INDEX IDX_78240498BEB399D5 (fuzId),
    INDEX IDX_782404989A5BAE65 (barId),
    PRIMARY KEY(Pk)
) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;

ALTER TABLE fuz ADD CONSTRAINT FK_51837B119A5BAE65 FOREIGN KEY (barId) REFERENCES bar (id);

ALTER TABLE baz ADD CONSTRAINT FK_78240498BEB399D5 FOREIGN KEY (fuzId) REFERENCES fuz (id);

ALTER TABLE baz ADD CONSTRAINT FK_782404989A5BAE65 FOREIGN KEY (barId) REFERENCES bar (id);
T
, $builder->toSql());
    }

    public function testItConstraintsFkErrorThrowException(): void
    {
        $this->expectException(DatabaseValidationException::class);
        $this->expectExceptionMessage('Tables in foreign');

        $schema = new Schema('bar', 'title', [
            new SchemaAttribute('Pk', 'string', 'pk|required'),
            new SchemaAttribute('foo', 'string', 'minlength:10|maxlength:100'),
            new SchemaAttribute('bar', 'integer', 'min:10|max'),
        ]);

        $schemaFk = new Schema('fuz', 'title', [
            new SchemaAttribute('Pk', 'integer', 'pk|ai|required'),
            new SchemaAttribute('barId', 'integer', 'fk:notexist'),
        ]);

        $builder = new Builder('MySQL');
        $builder->createTable($schema);
        $builder->createTable($schemaFk);

        $builder->toSql();
    }

    public function getSchema(): SchemaInterface
    {
        return new Schema('bar', 'title', [
            new SchemaAttribute('foo', 'integer', [
                'min' => 10,
                'max' => 100,
            ]),
        ]);
    }
}


1			<?php declare(strict_types=1);
2			/*
3			* This file is part of FlexPHP.
4			*
5			* (c) Freddie Gar <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10			namespace FlexPHP\Database\Tests\Unit;
11
12			use FlexPHP\Database\Builder;
13			use FlexPHP\Database\Exception\DatabaseValidationException;
14			use FlexPHP\Database\Tests\TestCase;
15			use FlexPHP\Schema\Schema;
16			use FlexPHP\Schema\SchemaAttribute;
17			use FlexPHP\Schema\SchemaInterface;
18
19			class BuilderTest extends TestCase
20			{
21			public function testItPlatformErrorThrowException(): void
22			{
23			$this->expectException(DatabaseValidationException::class);
24			$this->expectExceptionMessage('try: MySQL, SQLSrv');
25
26			new Builder('Unknow');
27			}
28
29			public function testItDatabaseNameErrorThrowException(): void
30			{
31			$this->expectException(DatabaseValidationException::class);
32			$this->expectExceptionMessage('Database name [_db] invalid');
33
34			$builder = new Builder('MySQL');
35			$builder->createDatabase('_db');
36			}
37
38			public function testItCreateMySQLDatabase(): void
39			{
40			$name = 'db';
41
42			$builder = new Builder('MySQL');
43			$builder->createDatabase($name);
44			$this->assertEquals(<<<T
45			CREATE DATABASE $name CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
46			T
47			, $builder->toSql());
48			}
49
50			public function testItCreateSQLSrvDatabase(): void
51			{
52			$name = 'db';
53
54			$builder = new Builder('SQLSrv');
55			$builder->createDatabase($name);
56			$this->assertEquals(<<<T
57			CREATE DATABASE $name COLLATE latin1_general_100_ci_ai_sc;
58			T
59			, $builder->toSql());
60			}
61
62			public function testItCreateSQLiteDatabase(): void
63			{
64			$name = 'db';
65
66			$builder = new Builder('SQLite');
67			$builder->createDatabase($name);
68			$this->assertEquals(<<<T
69			T
70			, $builder->toSql());
71			}
72
73			public function testItCreateMySQLDatabaseWithUse(): void
74			{
75			$name = 'db';
76
77			$builder = new Builder('MySQL');
78			$builder->createDatabaseWithUse($name);
79			$this->assertEquals(<<<T
80			CREATE DATABASE $name CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
81
82			USE $name;
83			T
84			, $builder->toSql());
85			}
86
87			public function testItCreateSQLSrvDatabaseWithUse(): void
88			{
89			$name = 'db';
90
91			$builder = new Builder('SQLSrv');
92			$builder->createDatabaseWithUse($name);
93			$this->assertEquals(<<<T
94			CREATE DATABASE $name COLLATE latin1_general_100_ci_ai_sc;
95			T
96			, $builder->toSql());
97			}
98
99			public function testItCreateSQLiteDatabaseWithUse(): void
100			{
101			$name = 'db';
102
103			$builder = new Builder('SQLite');
104			$builder->createDatabaseWithUse($name);
105			$this->assertEquals(<<<T
106			T
107			, $builder->toSql());
108			}
109
110			public function testItCreateMySQLUser(): void
111			{
112			$name = 'mysql';
113			$password = 'p4sw00rd';
114
115			$builder = new Builder('MySQL');
116			$builder->createUser($name, $password);
117			$this->assertEquals(<<<T
118			CREATE USER '$name'@'%' IDENTIFIED BY '$password';
119			T
120			, $builder->toSql());
121			}
122
123			public function testItCreateSQLSrvUser(): void
124			{
125			$name = 'sqlsrv';
126			$password = 'p4sw00rd';
127
128			$builder = new Builder('SQLSrv');
129			$builder->createUser($name, $password);
130			$this->assertEquals(<<<T
131			CREATE LOGIN $name WITH PASSWORD = '$password';
132			GO
133			CREATE USER $name FOR LOGIN $name;
134			GO
135			T
136			, $builder->toSql());
137			}
138
139			public function testItCreateSQLiteUser(): void
140			{
141			$name = 'sqlite';
142			$password = 'p4sw00rd';
143
144			$builder = new Builder('SQLite');
145			$builder->createUser($name, $password);
146			$this->assertEquals(<<<T
147			T
148			, $builder->toSql());
149			}
150
151			public function testItCreateMySQLUserWithGrants(): void
152			{
153			$name = 'mysql';
154			$password = 'p4sw00rd';
155
156			$builder = new Builder('MySQL');
157			$builder->createUser($name, $password, 'host', ['ALL PRIVILEGES']);
158			$this->assertEquals(<<<T
159			CREATE USER '$name'@'host' IDENTIFIED BY '$password';
160
161			GRANT ALL PRIVILEGES ON . TO '$name'@'host';
162			T
163			, $builder->toSql());
164			}
165
166			public function testItCreateSQLSrvUserWithGrants(): void
167			{
168			$name = 'sqlsrv';
169			$password = 'p4sw00rd';
170
171			$builder = new Builder('SQLSrv');
172			$builder->createUser($name, $password, 'host', ['ALL PRIVILEGES']);
173			$this->assertEquals(<<<T
174			CREATE LOGIN $name WITH PASSWORD = '$password';
175			GO
176			CREATE USER $name FOR LOGIN $name;
177			GO
178
179			GRANT ALL TO $name;
180			GO
181			T
182			, $builder->toSql());
183			}
184
185			public function testItCreateSQLiteUserWithGrants(): void
186			{
187			$name = 'sqlite';
188			$password = 'p4sw00rd';
189
190			$builder = new Builder('SQLite');
191			$builder->createUser($name, $password, 'host', ['ALL PRIVILEGES']);
192			$this->assertEquals(<<<T
193			T
194			, $builder->toSql());
195			}
196
197			public function testItCreateMySQLTable(): void
198			{
199			$builder = new Builder('MySQL');
200			$builder->createTable($this->getSchema());
201			$this->assertEquals(<<<T
202			CREATE TABLE bar (
203			foo INT DEFAULT NULL COMMENT 'foo'
204			) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;
205			T
206			, $builder->toSql());
207			}
208
209			public function testItCreateSQLSrvTable(): void
210			{
211			$builder = new Builder('SQLSrv');
212			$builder->createTable($this->getSchema());
213			$this->assertEquals(<<<T
214			CREATE TABLE bar (
215			foo INT
216			);
217
218			EXEC sp_addextendedproperty N'MS_Description', N'foo', N'SCHEMA', 'dbo', N'TABLE', 'bar', N'COLUMN', foo;
219			T
220			, $builder->toSql());
221			}
222
223			public function testItCreateSQLiteTable(): void
224			{
225			$builder = new Builder('SQLite');
226			$builder->createTable($this->getSchema());
227			$this->assertEquals(<<<T
228			CREATE TABLE bar (
229			foo INTEGER DEFAULT NULL
230			);
231			T
232			, $builder->toSql());
233			}
234
235			public function testItCreateMySQLComplete(): void
236			{
237			$dbname = 'complete';
238			$username = 'username';
239			$password = 'password';
240			$host = 'host';
241			$schema = new Schema('bar', 'title', [
242			new SchemaAttribute('Pk', 'string', 'pk\|required'),
243			new SchemaAttribute('foo', 'string', 'minlength:10\|maxlength:100'),
244			new SchemaAttribute('bar', 'integer', 'min:10\|max'),
245			]);
246
247			$schemaFk = new Schema('fuz', 'title', [
248			new SchemaAttribute('Pk', 'integer', 'pk\|ai\|required'),
249			new SchemaAttribute('barId', 'integer', 'fk:bar'),
250			]);
251
252			$builder = new Builder('MySQL');
253			$builder->createDatabaseWithUse($dbname);
254			$builder->createUser($username, $password, $host, ['ALL PRIVILEGES'], $dbname);
255			$builder->createTable($schema);
256			$builder->createTable($schemaFk);
257
258			$this->assertEquals(<<<T
259			CREATE DATABASE $dbname CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
260
261			USE $dbname;
262
263			CREATE USER '$username'@'$host' IDENTIFIED BY '$password';
264
265			GRANT ALL PRIVILEGES ON $dbname.* TO '$username'@'$host';
266
267			CREATE TABLE bar (
268			Pk VARCHAR(255) NOT NULL COMMENT 'Pk',
269			foo VARCHAR(100) DEFAULT NULL COMMENT 'foo',
270			bar INT DEFAULT NULL COMMENT 'bar',
271			PRIMARY KEY(Pk)
272			) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;
273
274			CREATE TABLE fuz (
275			Pk INT AUTO_INCREMENT NOT NULL COMMENT 'Pk',
276			barId INT DEFAULT NULL COMMENT 'barId',
277			INDEX IDX_51837B119A5BAE65 (barId),
278			PRIMARY KEY(Pk)
279			) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;
280
281			ALTER TABLE fuz ADD CONSTRAINT FK_51837B119A5BAE65 FOREIGN KEY (barId) REFERENCES bar (id);
282			T
283			, $builder->toSql());
284			}
285
286			public function testItConstraints(): void
287			{
288			$dbname = 'complete';
289			$username = 'username';
290			$password = 'password';
291			$host = 'host';
292			$schema = new Schema('bar', 'title', [
293			new SchemaAttribute('Pk', 'string', 'pk\|required'),
294			new SchemaAttribute('foo', 'string', 'minlength:10\|maxlength:100'),
295			new SchemaAttribute('bar', 'integer', 'min:10\|max'),
296			]);
297
298			$schemaFk = new Schema('fuz', 'title', [
299			new SchemaAttribute('Pk', 'integer', 'pk\|ai\|required'),
300			new SchemaAttribute('barId', 'integer', 'fk:bar'),
301			]);
302
303			$schemaFk2 = new Schema('baz', 'title', [
304			new SchemaAttribute('Pk', 'integer', 'pk\|ai\|required'),
305			new SchemaAttribute('fuzId', 'integer', 'fk:fuz'),
306			new SchemaAttribute('barId', 'integer', 'fk:bar'),
307			]);
308
309			$builder = new Builder('MySQL');
310			$builder->createDatabase($dbname);
311			$builder->createUser($username, $password, $host);
312			$builder->createTable($schema);
313			$builder->createTable($schemaFk);
314			$builder->createTable($schemaFk2);
315
316			$this->assertEquals(<<<T
317			CREATE DATABASE $dbname CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
318
319			CREATE USER '$username'@'$host' IDENTIFIED BY '$password';
320
321			CREATE TABLE bar (
322			Pk VARCHAR(255) NOT NULL COMMENT 'Pk',
323			foo VARCHAR(100) DEFAULT NULL COMMENT 'foo',
324			bar INT DEFAULT NULL COMMENT 'bar',
325			PRIMARY KEY(Pk)
326			) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;
327
328			CREATE TABLE fuz (
329			Pk INT AUTO_INCREMENT NOT NULL COMMENT 'Pk',
330			barId INT DEFAULT NULL COMMENT 'barId',
331			INDEX IDX_51837B119A5BAE65 (barId),
332			PRIMARY KEY(Pk)
333			) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;
334
335			CREATE TABLE baz (
336			Pk INT AUTO_INCREMENT NOT NULL COMMENT 'Pk',
337			fuzId INT DEFAULT NULL COMMENT 'fuzId',
338			barId INT DEFAULT NULL COMMENT 'barId',
339			INDEX IDX_78240498BEB399D5 (fuzId),
340			INDEX IDX_782404989A5BAE65 (barId),
341			PRIMARY KEY(Pk)
342			) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ENGINE = InnoDB;
343
344			ALTER TABLE fuz ADD CONSTRAINT FK_51837B119A5BAE65 FOREIGN KEY (barId) REFERENCES bar (id);
345
346			ALTER TABLE baz ADD CONSTRAINT FK_78240498BEB399D5 FOREIGN KEY (fuzId) REFERENCES fuz (id);
347
348			ALTER TABLE baz ADD CONSTRAINT FK_782404989A5BAE65 FOREIGN KEY (barId) REFERENCES bar (id);
349			T
350			, $builder->toSql());
351			}
352
353			public function testItConstraintsFkErrorThrowException(): void
354			{
355			$this->expectException(DatabaseValidationException::class);
356			$this->expectExceptionMessage('Tables in foreign');
357
358			$schema = new Schema('bar', 'title', [
359			new SchemaAttribute('Pk', 'string', 'pk\|required'),
360			new SchemaAttribute('foo', 'string', 'minlength:10\|maxlength:100'),
361			new SchemaAttribute('bar', 'integer', 'min:10\|max'),
362			]);
363
364			$schemaFk = new Schema('fuz', 'title', [
365			new SchemaAttribute('Pk', 'integer', 'pk\|ai\|required'),
366			new SchemaAttribute('barId', 'integer', 'fk:notexist'),
367			]);
368
369			$builder = new Builder('MySQL');
370			$builder->createTable($schema);
371			$builder->createTable($schemaFk);
372
373			$builder->toSql();
374			}
375
376			public function getSchema(): SchemaInterface
377			{
378			return new Schema('bar', 'title', [
379			new SchemaAttribute('foo', 'integer', [
380			'min' => 10,
381			'max' => 100,
382			]),
383			]);
384			}
385			}
386

flexphp / flex-database

Push — develop ( 58ca2f...a1a700 )

BuilderTest::testItCreateSQLiteUserWithGrants() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like