golang/ent
1
0
Fork 0
mirror of https://github.com/ent/ent.git synced 2026-04-28 05:30:56 +03:00
Code Issues Packages Projects Releases Wiki Activity

add tests for sqlite migration

Browse Source 
Summary: Pull Request resolved: https://github.com/facebookincubator/ent/pull/5

Reviewed By: alexsn

Differential Revision: D15875669

fbshipit-source-id: 5ddebe396b9683f364e91f2f9e6296e3659ff618
This commit is contained in:
Ariel Mashraki
2019-06-18 10:52:17 -07:00
committed by Facebook Github Bot
parent 5f0268e02c
commit 970a410b31
4 changed files with 176 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
dialect/sql/schema/mysql.go
View File

@@ -22,18 +22,25 @@ func (d *MySQL) Create(ctx context.Context, tables ...*Table) error {
if err != nil {
return err
}
if err := d.create(ctx, tx, tables...); err != nil {
return rollback(tx, fmt.Errorf("dialect/mysql: %v", err))
}
return tx.Commit()
}
func (d *MySQL) create(ctx context.Context, tx dialect.Tx, tables ...*Table) error {
for _, t := range tables {
switch exist, err := d.tableExist(ctx, tx, t.Name); {
case err != nil:
return rollback(tx, err)
return err
case exist:
curr, err := d.table(ctx, tx, t.Name)
if err != nil {
return rollback(tx, err)
return err
}
changes, err := changeSet(curr, t)
if err != nil {
return rollback(tx, err)
return err
}
if len(changes.Columns) > 0 {
b := sql.AlterTable(curr.Name)
@@ -42,7 +49,7 @@ func (d *MySQL) Create(ctx context.Context, tables ...*Table) error {
}
query, args := b.Query()
if err := tx.Exec(ctx, query, args, new(sql.Result)); err != nil {
return rollback(tx, fmt.Errorf("sql/mysql: alter table %q: %v", t.Name, err))
return fmt.Errorf("alter table %q: %v", t.Name, err)
}
}
if len(changes.Indexes) > 0 {
@@ -51,7 +58,7 @@ func (d *MySQL) Create(ctx context.Context, tables ...*Table) error {
default: // !exist
query, args := t.DSL().Query()
if err := tx.Exec(ctx, query, args, new(sql.Result)); err != nil {
return rollback(tx, fmt.Errorf("sql/mysql: create table %q: %v", t.Name, err))
return fmt.Errorf("create table %q: %v", t.Name, err)
}
}
}
@@ -66,7 +73,7 @@ func (d *MySQL) Create(ctx context.Context, tables ...*Table) error {
fk.Symbol = symbol(fk.Symbol)
exist, err := d.fkExist(ctx, tx, fk.Symbol)
if err != nil {
return rollback(tx, err)
return err
}
if !exist {
fks = append(fks, fk)
@@ -81,10 +88,10 @@ func (d *MySQL) Create(ctx context.Context, tables ...*Table) error {
}
query, args := b.Query()
if err := tx.Exec(ctx, query, args, new(sql.Result)); err != nil {
return rollback(tx, fmt.Errorf("sql/mysql: create foreign keys for %q: %v", t.Name, err))
return fmt.Errorf("create foreign keys for %q: %v", t.Name, err)
}
}
return tx.Commit()
return nil
}
func (d *MySQL) tableExist(ctx context.Context, tx dialect.Tx, name string) (bool, error) {

7
dialect/sql/schema/mysql_test.go
View File

@@ -21,6 +21,13 @@ func TestMySQL_Create(t *testing.T) {
before func(sqlmock.Sqlmock)
wantErr bool
}{
{
name: "tx failed",
before: func(mock sqlmock.Sqlmock) {
mock.ExpectBegin().WillReturnError(sqlmock.ErrCancelled)
},
wantErr: true,
},
{
name: "no tables",
before: func(mock sqlmock.Sqlmock) {

24
dialect/sql/schema/sqlite.go
View File

@@ -19,30 +19,36 @@ func (d *SQLite) Create(ctx context.Context, tables ...*Table) error {
if err != nil {
return err
}
if err := d.create(ctx, tx, tables...); err != nil {
return rollback(tx, fmt.Errorf("dialect/sqlite: %v", err))
}
return tx.Commit()
}
func (d *SQLite) create(ctx context.Context, tx dialect.Tx, tables ...*Table) error {
on, err := d.fkEnabled(ctx, tx)
if err != nil {
return fmt.Errorf("sql/sqlite: check foreign_keys pragma: %v", err)
return fmt.Errorf("check foreign_keys pragma: %v", err)
}
if !on {
// foreign_keys pragma is off, either enable it by execute "PRAGMA foreign_keys=ON"
// or add the following parameter in the connection string "_fk=1".
return fmt.Errorf("sql/sqlite: foreign_keys pragma is off: missing %q is the connection string", "_fk=1")
return fmt.Errorf("foreign_keys pragma is off: missing %q is the connection string", "_fk=1")
}
for _, t := range tables {
exist, err := d.tableExist(ctx, tx, t.Name)
if err != nil {
return rollback(tx, err)
return err
}
if exist {
continue
}
query, args := t.SQLite().Query()
if err := tx.Exec(ctx, query, args, new(sql.Result)); err != nil {
err = fmt.Errorf("sql/sqlite: create table %q: %v", t.Name, err)
return rollback(tx, err)
return fmt.Errorf("create table %q: %v", t.Name, err)
}
}
return tx.Commit()
return nil
}
func (d *SQLite) tableExist(ctx context.Context, tx dialect.Tx, name string) (bool, error) {
@@ -60,15 +66,15 @@ func (d *SQLite) fkEnabled(ctx context.Context, tx dialect.Tx) (bool, error) {
func (d *SQLite) exist(ctx context.Context, tx dialect.Tx, query string, args ...interface{}) (bool, error) {
rows := &sql.Rows{}
if err := tx.Query(ctx, query, args, rows); err != nil {
return false, fmt.Errorf("dialect/sqlite: reading schema information %v", err)
return false, fmt.Errorf("reading schema information %v", err)
}
defer rows.Close()
if !rows.Next() {
return false, fmt.Errorf("dialect/sqlite: no rows returned")
return false, fmt.Errorf("no rows returned")
}
var n int
if err := rows.Scan(&n); err != nil {
return false, fmt.Errorf("dialect/sqlite: scanning count")
return false, fmt.Errorf("scanning count")
}
return n > 0, nil
}

139
dialect/sql/schema/sqlite_test.go Normal file
View File

@@ -0,0 +1,139 @@
package schema
import (
"context"
"testing"
"fbc/ent/dialect/sql"
"fbc/ent/field"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
)
func TestSQLite_Create(t *testing.T) {
null := true
tests := []struct {
name string
tables []*Table
before func(sqlmock.Sqlmock)
wantErr bool
}{
{
name: "tx failed",
before: func(mock sqlmock.Sqlmock) {
mock.ExpectBegin().WillReturnError(sqlmock.ErrCancelled)
},
wantErr: true,
},
{
name: "fk disabled",
before: func(mock sqlmock.Sqlmock) {
mock.ExpectBegin()
mock.ExpectQuery("PRAGMA foreign_keys").
WillReturnRows(sqlmock.NewRows([]string{"foreign_keys"}).AddRow(0))
mock.ExpectRollback()
},
wantErr: true,
},
{
name: "no tables",
before: func(mock sqlmock.Sqlmock) {
mock.ExpectBegin()
mock.ExpectQuery("PRAGMA foreign_keys").
WillReturnRows(sqlmock.NewRows([]string{"foreign_keys"}).AddRow(1))
mock.ExpectCommit()
},
},
{
name: "create new table",
tables: []*Table{
{
Name: "users",
PrimaryKey: []*Column{
{Name: "id", Type: field.TypeInt, Increment: true},
},
Columns: []*Column{
{Name: "id", Type: field.TypeInt, Increment: true},
{Name: "name", Type: field.TypeString, Nullable: &null},
{Name: "age", Type: field.TypeInt},
},
},
},
before: func(mock sqlmock.Sqlmock) {
mock.ExpectBegin()
mock.ExpectQuery("PRAGMA foreign_keys").
WillReturnRows(sqlmock.NewRows([]string{"foreign_keys"}).AddRow(1))
mock.ExpectQuery(escape("SELECT COUNT(*) FROM `sqlite_master` WHERE `type` = ? AND `name` = ?")).
WithArgs("table", "users").
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
mock.ExpectExec(escape("CREATE TABLE `users`(`id` integer PRIMARY KEY AUTOINCREMENT, `name` varchar(255) NULL, `age` integer)")).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectCommit()
},
},
{
name: "create new table with foreign key",
tables: func() []*Table {
var (
c1 = []*Column{
{Name: "id", Type: field.TypeInt, Increment: true},
{Name: "name", Type: field.TypeString, Nullable: &null},
{Name: "created_at", Type: field.TypeTime},
}
c2 = []*Column{
{Name: "id", Type: field.TypeInt, Increment: true},
{Name: "name", Type: field.TypeString},
{Name: "owner_id", Type: field.TypeInt},
}
t1 = &Table{
Name: "users",
Columns: c1,
PrimaryKey: c1[0:1],
}
t2 = &Table{
Name: "pets",
Columns: c2,
PrimaryKey: c2[0:1],
ForeignKeys: []*ForeignKey{
{
Symbol: "pets_owner",
Columns: c2[2:],
RefTable: t1,
RefColumns: c1[0:1],
OnDelete: Cascade,
},
},
}
)
return []*Table{t1, t2}
}(),
before: func(mock sqlmock.Sqlmock) {
mock.ExpectBegin()
mock.ExpectQuery("PRAGMA foreign_keys").
WillReturnRows(sqlmock.NewRows([]string{"foreign_keys"}).AddRow(1))
mock.ExpectQuery(escape("SELECT COUNT(*) FROM `sqlite_master` WHERE `type` = ? AND `name` = ?")).
WithArgs("table", "users").
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
mock.ExpectExec(escape("CREATE TABLE `users`(`id` integer PRIMARY KEY AUTOINCREMENT, `name` varchar(255) NULL, `created_at` datetime)")).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectQuery(escape("SELECT COUNT(*) FROM `sqlite_master` WHERE `type` = ? AND `name` = ?")).
WithArgs("table", "pets").
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
mock.ExpectExec(escape("CREATE TABLE `pets`(`id` integer PRIMARY KEY AUTOINCREMENT, `name` varchar(255), `owner_id` integer, FOREIGN KEY(`owner_id`) REFERENCES `users`(`id`) ON DELETE CASCADE)")).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectCommit()
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
db, mock, err := sqlmock.New()
require.NoError(t, err)
tt.before(mock)
sqlite := &SQLite{sql.OpenDB("sqlite", db)}
err = sqlite.Create(context.Background(), tt.tables...)
require.Equal(t, tt.wantErr, err != nil, err)
})
}
}