func (r *SqlmockQueryer) Args(args ...driver.Value) Queryer {
	expectation := r.query.WithArgs(args...)
	return &SqlmockQueryer{query: expectation}
}
Args sets the args that queries should be executed with
package gormexpect
import (
	"database/sql"
	"database/sql/driver"
	"github.com/jinzhu/gorm"
	sqlmock "gopkg.in/DATA-DOG/go-sqlmock.v1"
)
var (
	db   *sql.DB
	mock sqlmock.Sqlmock
)
func init() {
	var err error
	db, mock, err = sqlmock.NewWithDSN("mock_gorm_dsn")
	if err != nil {
		panic(err.Error())
	}
}
type Adapter interface {
	ExpectQuery(stmt Stmt) Queryer
	ExpectExec(stmt Stmt) Execer
	ExpectBegin() TxBeginner
	ExpectCommit() TxCommitter
	ExpectRollback() TxRollback
	AssertExpectations() error
}
func NewSqlmockAdapter(dialect string, args ...interface{}) (*gorm.DB, Adapter, error) {
	gormDb, err := gorm.Open("sqlmock", "mock_gorm_dsn")
	if err != nil {
		return nil, nil, err
	}
	return gormDb, &SqlmockAdapter{db: db, mocker: mock}, nil
}
type SqlmockAdapter struct {
	db     *sql.DB
	mocker sqlmock.Sqlmock
}
func (a *SqlmockAdapter) ExpectQuery(query Stmt) Queryer {
	expectation := a.mocker.ExpectQuery(query.sql)
	return &SqlmockQueryer{query: expectation}
}
func (a *SqlmockAdapter) ExpectExec(exec Stmt) Execer {
	expectation := a.mocker.ExpectExec(exec.sql)
	return &SqlmockExecer{exec: expectation}
}
func (a *SqlmockAdapter) ExpectBegin() TxBeginner {
	expectation := a.mocker.ExpectBegin()
	return &SqlmockTxBeginner{begin: expectation}
}
func (a *SqlmockAdapter) ExpectCommit() TxCommitter {
	expectation := a.mocker.ExpectCommit()
	return &SqlmockTxCommitter{commit: expectation}
}
func (a *SqlmockAdapter) ExpectRollback() TxRollback {
	expectation := a.mocker.ExpectRollback()
	return &SqlmockTxRollback{rollback: expectation}
}
func (a *SqlmockAdapter) AssertExpectations() error {
	return a.mocker.ExpectationsWereMet()
}
type Queryer interface {
	Returns(rows interface{}) Queryer
	Errors(err error) Queryer
	Args(args ...driver.Value) Queryer
}
type SqlmockQueryer struct {
	query *sqlmock.ExpectedQuery
}
func (r *SqlmockQueryer) Returns(rows interface{}) Queryer {
	sqlmockRows, ok := rows.(*sqlmock.Rows)
	if !ok {
		panic("Unsupported type passed to Returns")
	}
	expectation := r.query.WillReturnRows(sqlmockRows)
	return &SqlmockQueryer{query: expectation}
}
func (r *SqlmockQueryer) Errors(err error) Queryer {
	expectation := r.query.WillReturnError(err)
	return &SqlmockQueryer{query: expectation}
}