loader_test.go

package loader

import (
	"database/sql"
	"fmt"
	"log"
	"os"
	"reflect"
	"testing"

	_ "github.com/go-sql-driver/mysql"
	mysqltest "github.com/lestrrat-go/test-mysqld"
	"github.com/pkg/errors"
	"github.com/shogo82148/txmanager"
)

var (
	testMysqld *mysqltest.TestMysqld
)

type item struct {
	id   int
	name string
}

func TestNew(t *testing.T) {
	type Input struct {
		Driver  string
		Options []Option
	}

	type Output struct {
		Loader FixtureLoader
		Error  error
	}

	type Test struct {
		Title  string
		Input  Input
		Output Output
	}

	tests := []Test{
		Test{
			Title: "success: default config",
			Input: Input{
				Driver:  MySQL,
				Options: []Option{},
			},
			Output: Output{
				Loader: FixtureLoader{
					txManager:       txmanager.NewDB(nil),
					driver:          MySQL,
					bulkInsertLimit: defaultBulkInsertLimit,
				},
				Error: nil,
			},
		},
		Test{
			Title: "success: update option",
			Input: Input{
				Driver: MySQL,
				Options: []Option{
					Update(true),
				},
			},
			Output: Output{
				Loader: FixtureLoader{
					txManager:       txmanager.NewDB(nil),
					driver:          MySQL,
					update:          true,
					bulkInsertLimit: defaultBulkInsertLimit,
				},
				Error: nil,
			},
		},
		Test{
			Title: "success: delete option",
			Input: Input{
				Driver: MySQL,
				Options: []Option{
					Delete(true),
				},
			},
			Output: Output{
				Loader: FixtureLoader{
					txManager:       txmanager.NewDB(nil),
					driver:          MySQL,
					delete:          true,
					bulkInsertLimit: defaultBulkInsertLimit,
				},
				Error: nil,
			},
		},
		Test{
			Title: "success: use sqlite and delete option",
			Input: Input{
				Driver: "sqlite",
				Options: []Option{
					Delete(true),
				},
			},
			Output: Output{
				Loader: FixtureLoader{
					txManager:       txmanager.NewDB(nil),
					driver:          "sqlite",
					delete:          true,
					bulkInsertLimit: defaultBulkInsertLimit,
				},
				Error: nil,
			},
		},
		Test{
			Title: "success: update and bulk insert option",
			Input: Input{
				Driver: MySQL,
				Options: []Option{
					Update(true),
					BulkInsert(true),
				},
			},
			Output: Output{
				Loader: FixtureLoader{
					txManager:       txmanager.NewDB(nil),
					driver:          MySQL,
					update:          true,
					bulkInsert:      true,
					bulkInsertLimit: defaultBulkInsertLimit,
				},
				Error: nil,
			},
		},
		Test{
			Title: "error: update support only mysql",
			Input: Input{
				Driver: "sqlite",
				Options: []Option{
					Update(true),
				},
			},
			Output: Output{
				Error: fmt.Errorf("error `update` option only support mysql"),
			},
		},
		Test{
			Title: "error: set update option with ignore option",
			Input: Input{
				Driver: MySQL,
				Options: []Option{
					Update(true),
					Ignore(true),
				},
			},
			Output: Output{
				Error: fmt.Errorf("error `update` and `ignore` are exclusive option"),
			},
		},
		Test{
			Title: "success: set bulkInsertLimit option",
			Input: Input{
				Driver: MySQL,
				Options: []Option{
					BulkInsertLimit(100),
				},
			},
			Output: Output{
				Loader: FixtureLoader{
					txManager:       txmanager.NewDB(nil),
					driver:          MySQL,
					bulkInsertLimit: 100,
				},
				Error: nil,
			},
		},
		Test{
			Title: "error: set bulkInsertLimit option of zero",
			Input: Input{
				Driver: MySQL,
				Options: []Option{
					BulkInsertLimit(0),
				},
			},
			Output: Output{
				Error: errors.New("error `bulkInsertLimit` is not allowed 0 value"),
			},
		},
	}

	for _, test := range tests {
		t.Run(test.Title, func(t *testing.T) {
			l, err := New(nil, test.Input.Driver, test.Input.Options...)
			if test.Output.Error != nil {
				if errors.Cause(err).Error() != test.Output.Error.Error() {
					t.Fatalf("error invalid error message. got:%s want:%s", errors.Cause(err).Error(), test.Output.Error.Error())
				}
				return
			}

			if err != nil {
				t.Fatal("error new", err.Error())
			}

			if !reflect.DeepEqual(l, test.Output.Loader) {
				t.Fatalf("error invalid options. got:%v want:%v", l, test.Output.Loader)
			}
		})
	}
}

func TestLoadFixrure(t *testing.T) {
	db, err := sql.Open("mysql", testMysqld.Datasource("test", "", "", 0))
	if err != nil {
		t.Fatal("[error] db connection", err.Error())
	}
	defer db.Close()

	_, err = db.Exec("CREATE TABLE item (id INTEGER PRIMARY KEY, name VARCHAR(255)) DEFAULT CHARACTER SET utf8mb4;")
	if err != nil {
		t.Fatal("[error] create table", err.Error())
	}

	type Input struct {
		File    string
		Options []Option
	}

	type Test struct {
		Title  string
		Input  Input
		Output []item
	}

	tests := []Test{
		Test{
			Title: "load csv",
			Input: Input{
				File:    "_data/item.csv",
				Options: []Option{},
			},
			Output: []item{
				item{id: 1, name: "エクスカリバー"},
				item{id: 2, name: "村正"},
			},
		},
		Test{
			Title: "load yml",
			Input: Input{
				File:    "_data/item.yaml",
				Options: []Option{},
			},
			Output: []item{
				item{id: 1, name: "エクスカリバー"},
				item{id: 2, name: "村正"},
				item{id: 3, name: "ウィザードロッド"},
				item{id: 4, name: "ホーリーランス"},
			},
		},
		Test{
			Title: "load json",
			Input: Input{
				File:    "_data/item.json",
				Options: []Option{},
			},
			Output: []item{
				item{id: 1, name: "エクスカリバー"},
				item{id: 2, name: "村正"},
				item{id: 3, name: "ウィザードロッド"},
				item{id: 4, name: "ホーリーランス"},
				item{id: 5, name: "グラディウス"},
				item{id: 6, name: "木刀"},
			},
		},
		Test{
			Title: "load csv with delete option",
			Input: Input{
				File: "_data/item.csv",
				Options: []Option{
					Delete(true),
				},
			},
			Output: []item{
				item{id: 1, name: "エクスカリバー"},
				item{id: 2, name: "村正"},
			},
		},
		Test{
			Title: "load csv with update and table option",
			Input: Input{
				File: "_data/item_update.csv",
				Options: []Option{
					Update(true),
					Table("item"),
				},
			},
			Output: []item{
				item{id: 1, name: "エクスカリバーNew"},
				item{id: 2, name: "村正New"},
			},
		},
		Test{
			Title: "load empty csv with delete and table option",
			Input: Input{
				File: "_data/zero.csv",
				Options: []Option{
					Delete(true),
					Table("item"),
				},
			},
			Output: []item{},
		},
		Test{
			Title: "load empty csv with delete and bulk insert and table option",
			Input: Input{
				File: "_data/zero.csv",
				Options: []Option{
					Delete(true),
					BulkInsert(true),
					Table("item"),
				},
			},
			Output: []item{},
		},
		Test{
			Title: "load csv with bulkInsert/bulkInsertLimit option/rows number is the multiple of bulkInsertLimit",
			Input: Input{
				File: "_data/bulkinsert.csv",
				Options: []Option{
					Delete(true),
					BulkInsert(true),
					BulkInsertLimit(2),
					Table("item"),
				},
			},
			Output: []item{
				item{id: 1, name: "item1"},
				item{id: 2, name: "item2"},
				item{id: 3, name: "item3"},
				item{id: 4, name: "item4"},
				item{id: 5, name: "item5"},
				item{id: 6, name: "item6"},
				item{id: 7, name: "item7"},
				item{id: 8, name: "item8"},
				item{id: 9, name: "item9"},
				item{id: 10, name: "item10"},
			},
		},
	}

	fl, err := New(db, MySQL)
	if err != nil {
		t.Fatal("[error] new ", err.Error())
	}

	for _, test := range tests {
		t.Run(test.Title, func(t *testing.T) {
			if err := fl.LoadFixture(test.Input.File, test.Input.Options...); err != nil {
				t.Fatal("[error] load fixture:", err.Error())
			}

			var count int
			row := db.QueryRow("SELECT COUNT(*) FROM item")
			if err := row.Scan(&count); err != nil {
				t.Fatal("[error] select error:", err.Error())
			}

			if len(test.Output) != count {
				t.Fatalf("error load data. want:%d got:%d", len(test.Output), count)
			}

			items := []item{}
			rows, err := db.Query("select id, name from item")
			if err != nil {
				t.Fatal("[error] select error:", err.Error())
			}

			for rows.Next() {
				i := item{}
				if err := rows.Scan(&i.id, &i.name); err != nil {
					if err != sql.ErrNoRows {
						t.Fatal("error scan data.", err.Error())
					}
				}

				items = append(items, i)
			}

			if !reflect.DeepEqual(test.Output, items) {
				t.Fatalf("error load data. want:%v got:%v", test.Output, items)
			}
		})
	}
}

func TestMain(m *testing.M) {
	mysqld, err := mysqltest.NewMysqld(nil)
	if err != nil {
		log.Fatalf("[error] setup test db: %s", err.Error())
	}

	db, err := sql.Open("mysql", mysqld.DSN(mysqltest.WithDbname("")))
	if err != nil {
		log.Fatalf("[error] connect db %s :%s", mysqld.DSN(mysqltest.WithDbname("")), err.Error())
	}

	// MySQL over 5.7 not exists test database
	_, err = db.Exec("CREATE DATABASE IF NOT EXISTS test")
	if err != nil {
		log.Fatalf("[error] create test db %s", err.Error())
	}

	testMysqld = mysqld
	defer mysqld.Stop()

	code := m.Run()
	os.Exit(code)
}