Improve tests (#1572)

fix test

Improve tests

Reviewed-on: https://gitea.com/xorm/xorm/pulls/1572

caches/leveldb.go

@@ -19,14 +19,14 @@ type LevelDBStore struct {
 
 var _ CacheStore = &LevelDBStore{}
 
-func NewLevelDBStore(dbfile string) *LevelDBStore {
+func NewLevelDBStore(dbfile string) (*LevelDBStore, error) {
 	db := &LevelDBStore{}
-	if h, err := leveldb.OpenFile(dbfile, nil); err != nil {
+	h, err := leveldb.OpenFile(dbfile, nil)
-		panic(err)
+	if err != nil {
-	} else {
+		return nil, err
-		db.store = h
 	}
-	return db
+	db.store = h
+	return db, nil
 }
 
 func (s *LevelDBStore) Put(key string, value interface{}) error {

caches/leveldb_test.go

@@ -11,7 +11,9 @@ import (
 )
 
 func TestLevelDBStore(t *testing.T) {
-	store := NewLevelDBStore("./level.db")
+	store, err := NewLevelDBStore("./level.db")
+	assert.NoError(t, err)
+
 	var kvs = map[string]interface{}{
 		"a": "b",
 	}

convert.go

@@ -346,3 +346,128 @@ func asBool(bs []byte) (bool, error) {
 	}
 	return strconv.ParseBool(string(bs))
 }
+
+// str2PK convert string value to primary key value according to tp
+func str2PKValue(s string, tp reflect.Type) (reflect.Value, error) {
+	var err error
+	var result interface{}
+	var defReturn = reflect.Zero(tp)
+
+	switch tp.Kind() {
+	case reflect.Int:
+		result, err = strconv.Atoi(s)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as int: %s", s, err.Error())
+		}
+	case reflect.Int8:
+		x, err := strconv.Atoi(s)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as int8: %s", s, err.Error())
+		}
+		result = int8(x)
+	case reflect.Int16:
+		x, err := strconv.Atoi(s)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as int16: %s", s, err.Error())
+		}
+		result = int16(x)
+	case reflect.Int32:
+		x, err := strconv.Atoi(s)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as int32: %s", s, err.Error())
+		}
+		result = int32(x)
+	case reflect.Int64:
+		result, err = strconv.ParseInt(s, 10, 64)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as int64: %s", s, err.Error())
+		}
+	case reflect.Uint:
+		x, err := strconv.ParseUint(s, 10, 64)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as uint: %s", s, err.Error())
+		}
+		result = uint(x)
+	case reflect.Uint8:
+		x, err := strconv.ParseUint(s, 10, 64)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as uint8: %s", s, err.Error())
+		}
+		result = uint8(x)
+	case reflect.Uint16:
+		x, err := strconv.ParseUint(s, 10, 64)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as uint16: %s", s, err.Error())
+		}
+		result = uint16(x)
+	case reflect.Uint32:
+		x, err := strconv.ParseUint(s, 10, 64)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as uint32: %s", s, err.Error())
+		}
+		result = uint32(x)
+	case reflect.Uint64:
+		result, err = strconv.ParseUint(s, 10, 64)
+		if err != nil {
+			return defReturn, fmt.Errorf("convert %s as uint64: %s", s, err.Error())
+		}
+	case reflect.String:
+		result = s
+	default:
+		return defReturn, errors.New("unsupported convert type")
+	}
+	return reflect.ValueOf(result).Convert(tp), nil
+}
+
+func str2PK(s string, tp reflect.Type) (interface{}, error) {
+	v, err := str2PKValue(s, tp)
+	if err != nil {
+		return nil, err
+	}
+	return v.Interface(), nil
+}
+
+func int64ToIntValue(id int64, tp reflect.Type) reflect.Value {
+	var v interface{}
+	kind := tp.Kind()
+
+	if kind == reflect.Ptr {
+		kind = tp.Elem().Kind()
+	}
+
+	switch kind {
+	case reflect.Int16:
+		temp := int16(id)
+		v = &temp
+	case reflect.Int32:
+		temp := int32(id)
+		v = &temp
+	case reflect.Int:
+		temp := int(id)
+		v = &temp
+	case reflect.Int64:
+		temp := id
+		v = &temp
+	case reflect.Uint16:
+		temp := uint16(id)
+		v = &temp
+	case reflect.Uint32:
+		temp := uint32(id)
+		v = &temp
+	case reflect.Uint64:
+		temp := uint64(id)
+		v = &temp
+	case reflect.Uint:
+		temp := uint(id)
+		v = &temp
+	}
+
+	if tp.Kind() == reflect.Ptr {
+		return reflect.ValueOf(v).Convert(tp)
+	}
+	return reflect.ValueOf(v).Elem().Convert(tp)
+}
+
+func int64ToInt(id int64, tp reflect.Type) interface{} {
+	return int64ToIntValue(id, tp).Interface()
+}

engine.go

@@ -1260,3 +1260,43 @@ func (engine *Engine) Unscoped() *Session {
 func (engine *Engine) tbNameWithSchema(v string) string {
 	return dialects.TableNameWithSchema(engine.dialect, v)
 }
+
+// Context creates a session with the context
+func (engine *Engine) Context(ctx context.Context) *Session {
+	session := engine.NewSession()
+	session.isAutoClose = true
+	return session.Context(ctx)
+}
+
+// SetDefaultContext set the default context
+func (engine *Engine) SetDefaultContext(ctx context.Context) {
+	engine.defaultContext = ctx
+}
+
+// PingContext tests if database is alive
+func (engine *Engine) PingContext(ctx context.Context) error {
+	session := engine.NewSession()
+	defer session.Close()
+	return session.PingContext(ctx)
+}
+
+// Transaction Execute sql wrapped in a transaction(abbr as tx), tx will automatic commit if no errors occurred
+func (engine *Engine) Transaction(f func(*Session) (interface{}, error)) (interface{}, error) {
+	session := engine.NewSession()
+	defer session.Close()
+
+	if err := session.Begin(); err != nil {
+		return nil, err
+	}
+
+	result, err := f(session)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := session.Commit(); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

engine_context.go

@@ -1,28 +0,0 @@
-// Copyright 2019 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.8
-
-package xorm
-
-import "context"
-
-// Context creates a session with the context
-func (engine *Engine) Context(ctx context.Context) *Session {
-	session := engine.NewSession()
-	session.isAutoClose = true
-	return session.Context(ctx)
-}
-
-// SetDefaultContext set the default context
-func (engine *Engine) SetDefaultContext(ctx context.Context) {
-	engine.defaultContext = ctx
-}
-
-// PingContext tests if database is alive
-func (engine *Engine) PingContext(ctx context.Context) error {
-	session := engine.NewSession()
-	defer session.Close()
-	return session.PingContext(ctx)
-}

engine_context_test.go

@@ -1,28 +0,0 @@
-// Copyright 2017 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.8
-
-package xorm
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestPingContext(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	ctx, canceled := context.WithTimeout(context.Background(), time.Nanosecond)
-	defer canceled()
-
-	time.Sleep(time.Nanosecond)
-
-	err := testEngine.(*Engine).PingContext(ctx)
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "context deadline exceeded")
-}

engine_test.go

@@ -5,6 +5,7 @@
 package xorm
 
 import (
+	"context"
 	"fmt"
 	"testing"
 	"time"
@@ -12,6 +13,19 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestPingContext(t *testing.T) {
+	assert.NoError(t, prepareEngine())
+
+	ctx, canceled := context.WithTimeout(context.Background(), time.Nanosecond)
+	defer canceled()
+
+	time.Sleep(time.Nanosecond)
+
+	err := testEngine.(*Engine).PingContext(ctx)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "context deadline exceeded")
+}
+
 func TestAutoTransaction(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 

error.go

@@ -37,13 +37,3 @@ type ErrFieldIsNotExist struct {
 func (e ErrFieldIsNotExist) Error() string {
 	return fmt.Sprintf("field %s is not valid on table %s", e.FieldName, e.TableName)
 }
-
-// ErrFieldIsNotValid is not valid
-type ErrFieldIsNotValid struct {
-	FieldName string
-	TableName string
-}
-
-func (e ErrFieldIsNotValid) Error() string {
-	return fmt.Sprintf("field %s is not valid on table %s", e.FieldName, e.TableName)
-}

helpers.go

@@ -1,163 +0,0 @@
-// Copyright 2015 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package xorm
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"time"
-)
-
-// str2PK convert string value to primary key value according to tp
-func str2PKValue(s string, tp reflect.Type) (reflect.Value, error) {
-	var err error
-	var result interface{}
-	var defReturn = reflect.Zero(tp)
-
-	switch tp.Kind() {
-	case reflect.Int:
-		result, err = strconv.Atoi(s)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as int: %s", s, err.Error())
-		}
-	case reflect.Int8:
-		x, err := strconv.Atoi(s)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as int8: %s", s, err.Error())
-		}
-		result = int8(x)
-	case reflect.Int16:
-		x, err := strconv.Atoi(s)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as int16: %s", s, err.Error())
-		}
-		result = int16(x)
-	case reflect.Int32:
-		x, err := strconv.Atoi(s)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as int32: %s", s, err.Error())
-		}
-		result = int32(x)
-	case reflect.Int64:
-		result, err = strconv.ParseInt(s, 10, 64)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as int64: %s", s, err.Error())
-		}
-	case reflect.Uint:
-		x, err := strconv.ParseUint(s, 10, 64)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as uint: %s", s, err.Error())
-		}
-		result = uint(x)
-	case reflect.Uint8:
-		x, err := strconv.ParseUint(s, 10, 64)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as uint8: %s", s, err.Error())
-		}
-		result = uint8(x)
-	case reflect.Uint16:
-		x, err := strconv.ParseUint(s, 10, 64)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as uint16: %s", s, err.Error())
-		}
-		result = uint16(x)
-	case reflect.Uint32:
-		x, err := strconv.ParseUint(s, 10, 64)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as uint32: %s", s, err.Error())
-		}
-		result = uint32(x)
-	case reflect.Uint64:
-		result, err = strconv.ParseUint(s, 10, 64)
-		if err != nil {
-			return defReturn, fmt.Errorf("convert %s as uint64: %s", s, err.Error())
-		}
-	case reflect.String:
-		result = s
-	default:
-		return defReturn, errors.New("unsupported convert type")
-	}
-	return reflect.ValueOf(result).Convert(tp), nil
-}
-
-func str2PK(s string, tp reflect.Type) (interface{}, error) {
-	v, err := str2PKValue(s, tp)
-	if err != nil {
-		return nil, err
-	}
-	return v.Interface(), nil
-}
-
-func int64ToIntValue(id int64, tp reflect.Type) reflect.Value {
-	var v interface{}
-	kind := tp.Kind()
-
-	if kind == reflect.Ptr {
-		kind = tp.Elem().Kind()
-	}
-
-	switch kind {
-	case reflect.Int16:
-		temp := int16(id)
-		v = &temp
-	case reflect.Int32:
-		temp := int32(id)
-		v = &temp
-	case reflect.Int:
-		temp := int(id)
-		v = &temp
-	case reflect.Int64:
-		temp := id
-		v = &temp
-	case reflect.Uint16:
-		temp := uint16(id)
-		v = &temp
-	case reflect.Uint32:
-		temp := uint32(id)
-		v = &temp
-	case reflect.Uint64:
-		temp := uint64(id)
-		v = &temp
-	case reflect.Uint:
-		temp := uint(id)
-		v = &temp
-	}
-
-	if tp.Kind() == reflect.Ptr {
-		return reflect.ValueOf(v).Convert(tp)
-	}
-	return reflect.ValueOf(v).Elem().Convert(tp)
-}
-
-func int64ToInt(id int64, tp reflect.Type) interface{} {
-	return int64ToIntValue(id, tp).Interface()
-}
-
-func makeArray(elem string, count int) []string {
-	res := make([]string, count)
-	for i := 0; i < count; i++ {
-		res[i] = elem
-	}
-	return res
-}
-
-func rType(bean interface{}) reflect.Type {
-	sliceValue := reflect.Indirect(reflect.ValueOf(bean))
-	// return reflect.TypeOf(sliceValue.Interface())
-	return sliceValue.Type()
-}
-
-func structName(v reflect.Type) string {
-	for v.Kind() == reflect.Ptr {
-		v = v.Elem()
-	}
-	return v.Name()
-}
-
-func formatTime(t time.Time) string {
-	return t.Format("2006-01-02 15:04:05")
-}

internal/statements/update.go

@@ -6,6 +6,7 @@ package statements
 
 import (
 	"database/sql/driver"
+	"errors"
 	"fmt"
 	"reflect"
 	"time"
@@ -200,8 +201,7 @@ func (statement *Statement) BuildUpdates(bean interface{},
 								continue
 							}
 						} else {
-							// TODO: how to handler?
+							return nil, nil, errors.New("Not supported multiple primary keys")
-							panic("not supported")
 						}
 					}
 				} else {
@@ -209,7 +209,7 @@ func (statement *Statement) BuildUpdates(bean interface{},
 					if requiredField || !utils.IsStructZero(fieldValue) {
 						bytes, err := json.DefaultJSONHandler.Marshal(fieldValue.Interface())
 						if err != nil {
-							panic(fmt.Sprintf("mashal %v failed", fieldValue.Interface()))
+							return nil, nil, fmt.Errorf("mashal %v failed", fieldValue.Interface())
 						}
 						if col.SQLType.IsText() {
 							val = string(bytes)

processors_test.go

@@ -125,17 +125,11 @@ func TestProcessors(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(&ProcessorsStruct{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	p := &ProcessorsStruct{}
 
 	err = testEngine.CreateTables(&ProcessorsStruct{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	b4InsertFunc := func(bean interface{}) {
 		if v, ok := (bean).(*ProcessorsStruct); ok {
@@ -259,42 +253,22 @@ func TestProcessors(t *testing.T) {
 	_, err = testEngine.Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
 	assert.NoError(t, err)
 
-	if p.B4UpdateFlag == 0 {
+	assert.False(t, p.B4UpdateFlag == 0, "B4UpdateFlag not set")
-		t.Error(errors.New("B4UpdateFlag not set"))
+	assert.False(t, p.AfterUpdatedFlag == 0, "AfterUpdatedFlag not set")
-	}
+	assert.False(t, p.B4UpdateViaExt == 0, "B4UpdateViaExt not set")
-	if p.AfterUpdatedFlag == 0 {
+	assert.False(t, p.AfterUpdatedViaExt == 0, "AfterUpdatedViaExt not set")
-		t.Error(errors.New("AfterUpdatedFlag not set"))
-	}
-	if p.B4UpdateViaExt == 0 {
-		t.Error(errors.New("B4UpdateViaExt not set"))
-	}
-	if p.AfterUpdatedViaExt == 0 {
-		t.Error(errors.New("AfterUpdatedViaExt not set"))
-	}
 
 	p2 = &ProcessorsStruct{}
 	has, err = testEngine.ID(p.Id).Get(p2)
 	assert.NoError(t, err)
 	assert.True(t, has)
 
-	if p2.B4UpdateFlag == 0 {
+	assert.False(t, p2.B4UpdateFlag == 0, "B4UpdateFlag not set")
-		t.Error(errors.New("B4UpdateFlag not set"))
+	assert.False(t, p2.AfterUpdatedFlag != 0, fmt.Sprintf("AfterUpdatedFlag is set: %d", p.AfterUpdatedFlag))
-	}
+	assert.False(t, p2.B4UpdateViaExt == 0, "B4UpdateViaExt not set")
-	if p2.AfterUpdatedFlag != 0 {
+	assert.False(t, p2.AfterUpdatedViaExt != 0, fmt.Sprintf("AfterUpdatedViaExt is set: %d", p.AfterUpdatedViaExt))
-		t.Error(errors.New("AfterUpdatedFlag is set: " + string(p.AfterUpdatedFlag)))
+	assert.False(t, p2.BeforeSetFlag != 9, fmt.Sprintf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
-	}
+	assert.False(t, p2.AfterSetFlag != 9, fmt.Sprintf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
-	if p2.B4UpdateViaExt == 0 {
-		t.Error(errors.New("B4UpdateViaExt not set"))
-	}
-	if p2.AfterUpdatedViaExt != 0 {
-		t.Error(errors.New("AfterUpdatedViaExt is set: " + string(p.AfterUpdatedViaExt)))
-	}
-	if p2.BeforeSetFlag != 9 {
-		t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
-	}
-	if p2.AfterSetFlag != 9 {
-		t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
-	}
 	// --
 
 	// test delete processors
@@ -450,12 +424,7 @@ func TestProcessorsTx(t *testing.T) {
 	p2 := &ProcessorsStruct{}
 	_, err = testEngine.ID(p.Id).Get(p2)
 	assert.NoError(t, err)
-
+	assert.False(t, p2.Id > 0, "tx got committed upon insert!?")
-	if p2.Id > 0 {
-		err = errors.New("tx got committed upon insert!?")
-		t.Error(err)
-		panic(err)
-	}
 	// --
 
 	// test insert processors with tx commit
@@ -846,7 +815,6 @@ func TestProcessorsTx(t *testing.T) {
 		t.Error(errors.New("AfterUpdatedFlag set"))
 	}
 	session.Close()
-	// --
 }
 
 type AfterLoadStructA struct {

session.go

@@ -22,6 +22,16 @@ import (
 	"xorm.io/xorm/schemas"
 )
 
+// ErrFieldIsNotValid is not valid
+type ErrFieldIsNotValid struct {
+	FieldName string
+	TableName string
+}
+
+func (e ErrFieldIsNotValid) Error() string {
+	return fmt.Sprintf("field %s is not valid on table %s", e.FieldName, e.TableName)
+}
+
 type sessionType int
 
 const (
@@ -883,3 +893,19 @@ func (session *Session) incrVersionFieldValue(fieldValue *reflect.Value) {
 		fieldValue.SetUint(fieldValue.Uint() + 1)
 	}
 }
+
+// Context sets the context on this session
+func (session *Session) Context(ctx context.Context) *Session {
+	session.ctx = ctx
+	return session
+}
+
+// PingContext test if database is ok
+func (session *Session) PingContext(ctx context.Context) error {
+	if session.isAutoClose {
+		defer session.Close()
+	}
+
+	session.engine.logger.Infof("PING DATABASE %v", session.engine.DriverName())
+	return session.DB().PingContext(ctx)
+}

session_cond_test.go

@@ -139,13 +139,11 @@ func TestIn(t *testing.T) {
 	users := make([]Userinfo, 0)
 	err = testEngine.In("id", ids[0], ids[1], ids[2]).Find(&users)
 	assert.NoError(t, err)
-	fmt.Println(users)
 	assert.EqualValues(t, 3, len(users))
 
 	users = make([]Userinfo, 0)
 	err = testEngine.In("id", ids).Find(&users)
 	assert.NoError(t, err)
-	fmt.Println(users)
 	assert.EqualValues(t, 3, len(users))
 
 	for _, user := range users {
@@ -163,7 +161,6 @@ func TestIn(t *testing.T) {
 
 	err = testEngine.Where(department+" = ?", "dev").In("id", idsInterface...).Find(&users)
 	assert.NoError(t, err)
-	fmt.Println(users)
 	assert.EqualValues(t, 3, len(users))
 
 	for _, user := range users {
@@ -177,7 +174,6 @@ func TestIn(t *testing.T) {
 
 	err = testEngine.In("id", 1).In("id", 2).In(department, dev).Find(&users)
 	assert.NoError(t, err)
-	fmt.Println(users)
 
 	cnt, err = testEngine.In("id", ids[0]).Update(&Userinfo{Departname: "dev-"})
 	assert.NoError(t, err)

session_context.go

@@ -1,23 +0,0 @@
-// Copyright 2019 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package xorm
-
-import "context"
-
-// Context sets the context on this session
-func (session *Session) Context(ctx context.Context) *Session {
-	session.ctx = ctx
-	return session
-}
-
-// PingContext test if database is ok
-func (session *Session) PingContext(ctx context.Context) error {
-	if session.isAutoClose {
-		defer session.Close()
-	}
-
-	session.engine.logger.Infof("PING DATABASE %v", session.engine.DriverName())
-	return session.DB().PingContext(ctx)
-}

session_context_test.go

@@ -1,36 +0,0 @@
-// Copyright 2019 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package xorm
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestQueryContext(t *testing.T) {
-	type ContextQueryStruct struct {
-		Id   int64
-		Name string
-	}
-
-	assert.NoError(t, prepareEngine())
-	assertSync(t, new(ContextQueryStruct))
-
-	_, err := testEngine.Insert(&ContextQueryStruct{Name: "1"})
-	assert.NoError(t, err)
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond)
-	defer cancel()
-
-	time.Sleep(time.Nanosecond)
-
-	has, err := testEngine.Context(ctx).Exist(&ContextQueryStruct{Name: "1"})
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "context deadline exceeded")
-	assert.False(t, has)
-}

session_delete_test.go

@@ -8,9 +8,10 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
 	"xorm.io/xorm/caches"
 	"xorm.io/xorm/schemas"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDelete(t *testing.T) {

session_exist_test.go

@@ -5,7 +5,9 @@
 package xorm
 
 import (
+	"context"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -181,3 +183,26 @@ func TestExistStructForJoin(t *testing.T) {
 	assert.NoError(t, err)
 	assert.True(t, has)
 }
+
+func TestExistContext(t *testing.T) {
+	type ContextQueryStruct struct {
+		Id   int64
+		Name string
+	}
+
+	assert.NoError(t, prepareEngine())
+	assertSync(t, new(ContextQueryStruct))
+
+	_, err := testEngine.Insert(&ContextQueryStruct{Name: "1"})
+	assert.NoError(t, err)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond)
+	defer cancel()
+
+	time.Sleep(time.Nanosecond)
+
+	has, err := testEngine.Context(ctx).Exist(&ContextQueryStruct{Name: "1"})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "context deadline exceeded")
+	assert.False(t, has)
+}

session_find_test.go

@@ -5,7 +5,6 @@
 package xorm
 
 import (
-	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -79,17 +78,11 @@ func TestWhere(t *testing.T) {
 
 	users := make([]Userinfo, 0)
 	err := testEngine.Where("id > ?", 2).Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	fmt.Println(users)
 
 	err = testEngine.Where("id > ?", 2).And("id < ?", 10).Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	fmt.Println(users)
 }
 
@@ -200,13 +193,7 @@ func TestFindMap(t *testing.T) {
 
 	users := make(map[int64]Userinfo)
 	err := testEngine.Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
-	for _, user := range users {
-		fmt.Println(user)
-	}
 }
 
 func TestFindMap2(t *testing.T) {
@@ -215,13 +202,7 @@ func TestFindMap2(t *testing.T) {
 
 	users := make(map[int64]*Userinfo)
 	err := testEngine.Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
-	for id, user := range users {
-		fmt.Println(id, user)
-	}
 }
 
 func TestDistinct(t *testing.T) {
@@ -239,8 +220,6 @@ func TestDistinct(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(users))
 
-	fmt.Println(users)
-
 	type Depart struct {
 		Departname string
 	}
@@ -248,12 +227,7 @@ func TestDistinct(t *testing.T) {
 	users2 := make([]Depart, 0)
 	err = testEngine.Distinct(departname).Table(new(Userinfo)).Find(&users2)
 	assert.NoError(t, err)
-	if len(users2) != 1 {
+	assert.EqualValues(t, 1, len(users2))
-		fmt.Println(len(users2))
-		t.Error(err)
-		panic(errors.New("should be one record"))
-	}
-	fmt.Println(users2)
 }
 
 func TestOrder(t *testing.T) {
@@ -263,12 +237,10 @@ func TestOrder(t *testing.T) {
 	users := make([]Userinfo, 0)
 	err := testEngine.OrderBy("id desc").Find(&users)
 	assert.NoError(t, err)
-	fmt.Println(users)
 
 	users2 := make([]Userinfo, 0)
 	err = testEngine.Asc("id", "username").Desc("height").Find(&users2)
 	assert.NoError(t, err)
-	fmt.Println(users2)
 }
 
 func TestGroupBy(t *testing.T) {
@@ -287,15 +259,6 @@ func TestHaving(t *testing.T) {
 	users := make([]Userinfo, 0)
 	err := testEngine.GroupBy("username").Having("username='xlw'").Find(&users)
 	assert.NoError(t, err)
-	fmt.Println(users)
-
-	/*users = make([]Userinfo, 0)
-	err = testEngine.Cols("id, username").GroupBy("username").Having("username='xlw'").Find(&users)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-	fmt.Println(users)*/
 }
 
 func TestOrderSameMapper(t *testing.T) {
@@ -315,12 +278,10 @@ func TestOrderSameMapper(t *testing.T) {
 	users := make([]Userinfo, 0)
 	err := testEngine.OrderBy("id desc").Find(&users)
 	assert.NoError(t, err)
-	fmt.Println(users)
 
 	users2 := make([]Userinfo, 0)
 	err = testEngine.Asc("id", "Username").Desc("Height").Find(&users2)
 	assert.NoError(t, err)
-	fmt.Println(users2)
 }
 
 func TestHavingSameMapper(t *testing.T) {
@@ -337,10 +298,7 @@ func TestHavingSameMapper(t *testing.T) {
 
 	users := make([]Userinfo, 0)
 	err := testEngine.GroupBy("`Username`").Having("`Username`='xlw'").Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(users)
 }
 
 func TestFindInts(t *testing.T) {
@@ -350,39 +308,24 @@ func TestFindInts(t *testing.T) {
 	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var idsInt64 []int64
 	err := testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsInt64)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsInt64)
 
 	var idsInt32 []int32
 	err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsInt32)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsInt32)
 
 	var idsInt []int
 	err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsInt)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsInt)
 
 	var idsUint []uint
 	err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsUint)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsUint)
 
 	type MyInt int
 	var idsMyInt []MyInt
 	err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsMyInt)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsMyInt)
 }
 
 func TestFindStrings(t *testing.T) {
@@ -392,10 +335,7 @@ func TestFindStrings(t *testing.T) {
 	username := testEngine.GetColumnMapper().Obj2Table("Username")
 	var idsString []string
 	err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsString)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsString)
 }
 
 func TestFindMyString(t *testing.T) {
@@ -406,10 +346,7 @@ func TestFindMyString(t *testing.T) {
 
 	var idsMyString []MyString
 	err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsMyString)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsMyString)
 }
 
 func TestFindInterface(t *testing.T) {
@@ -420,10 +357,7 @@ func TestFindInterface(t *testing.T) {
 	username := testEngine.GetColumnMapper().Obj2Table("Username")
 	var idsInterface []interface{}
 	err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsInterface)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	fmt.Println(idsInterface)
 }
 
 func TestFindSliceBytes(t *testing.T) {
@@ -433,12 +367,7 @@ func TestFindSliceBytes(t *testing.T) {
 	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var ids [][][]byte
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	for _, record := range ids {
-		fmt.Println(record)
-	}
 }
 
 func TestFindSlicePtrString(t *testing.T) {
@@ -448,12 +377,7 @@ func TestFindSlicePtrString(t *testing.T) {
 	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var ids [][]*string
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	for _, record := range ids {
-		fmt.Println(record)
-	}
 }
 
 func TestFindMapBytes(t *testing.T) {
@@ -463,12 +387,7 @@ func TestFindMapBytes(t *testing.T) {
 	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var ids []map[string][]byte
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
-	for _, record := range ids {
-		fmt.Println(record)
-	}
 }
 
 func TestFindMapPtrString(t *testing.T) {
@@ -479,9 +398,6 @@ func TestFindMapPtrString(t *testing.T) {
 	var ids []map[string]*string
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
 	assert.NoError(t, err)
-	for _, record := range ids {
-		fmt.Println(record)
-	}
 }
 
 func TestFindBit(t *testing.T) {
@@ -868,3 +784,25 @@ func TestMoreExtends(t *testing.T) {
 		Find(&books)
 	assert.NoError(t, err)
 }
+
+func TestDistinctAndCols(t *testing.T) {
+	type DistinctAndCols struct {
+		Id   int64
+		Name string
+	}
+
+	assert.NoError(t, prepareEngine())
+	assertSync(t, new(DistinctAndCols))
+
+	cnt, err := testEngine.Insert(&DistinctAndCols{
+		Name: "test",
+	})
+	assert.NoError(t, err)
+	assert.EqualValues(t, 1, cnt)
+
+	var names []string
+	err = testEngine.Table("distinct_and_cols").Cols("name").Distinct("name").Find(&names)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 1, len(names))
+	assert.EqualValues(t, "test", names[0])
+}

session_insert_test.go

@@ -5,7 +5,6 @@
 package xorm
 
 import (
-	"errors"
 	"fmt"
 	"reflect"
 	"testing"
@@ -154,9 +153,6 @@ func TestInsert(t *testing.T) {
 	// Username is unique, so this should return error
 	assert.Error(t, err, "insert should fail but no error returned")
 	assert.EqualValues(t, 0, cnt, "insert not returned 1")
-	if err == nil {
-		panic("should return err")
-	}
 }
 
 func TestInsertAutoIncr(t *testing.T) {
@@ -167,19 +163,9 @@ func TestInsertAutoIncr(t *testing.T) {
 	user := Userinfo{Username: "xiaolunwen2", Departname: "dev", Alias: "lunny", Created: time.Now(),
 		Detail: Userdetail{Id: 1}, Height: 1.78, Avatar: []byte{1, 2, 3}, IsMan: true}
 	cnt, err := testEngine.Insert(&user)
-	fmt.Println(user.Uid)
+	assert.NoError(t, err)
-	if err != nil {
+	assert.EqualValues(t, 1, cnt)
-		t.Error(err)
+	assert.Greater(t, user.Uid, int64(0))
-		panic(err)
-	}
-	if cnt != 1 {
-		err = errors.New("insert not returned 1")
-		t.Error(err)
-		panic(err)
-	}
-	if user.Uid <= 0 {
-		t.Error(errors.New("not return id error"))
-	}
 }
 
 type DefaultInsert struct {
@@ -203,26 +189,10 @@ func TestInsertDefault(t *testing.T) {
 
 	has, err := testEngine.Desc("id").Get(di)
 	assert.NoError(t, err)
-	if !has {
+	assert.True(t, has)
-		err = errors.New("error with no data")
+	assert.EqualValues(t, -1, di.Status)
-		t.Error(err)
+	assert.EqualValues(t, di2.Updated.Unix(), di.Updated.Unix())
-		panic(err)
+	assert.EqualValues(t, di2.Created.Unix(), di.Created.Unix())
-	}
-	if di.Status != -1 {
-		err = errors.New("inserted error data")
-		t.Error(err)
-		panic(err)
-	}
-	if di2.Updated.Unix() != di.Updated.Unix() {
-		err = errors.New("updated should equal")
-		t.Error(err, di.Updated, di2.Updated)
-		panic(err)
-	}
-	if di2.Created.Unix() != di.Created.Unix() {
-		err = errors.New("created should equal")
-		t.Error(err, di.Created, di2.Created)
-		panic(err)
-	}
 }
 
 type DefaultInsert2 struct {
@@ -237,53 +207,20 @@ func TestInsertDefault2(t *testing.T) {
 
 	di := new(DefaultInsert2)
 	err := testEngine.Sync2(di)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-	}
 
 	var di2 = DefaultInsert2{Name: "test"}
 	_, err = testEngine.Omit(testEngine.GetColumnMapper().Obj2Table("CheckTime")).Insert(&di2)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-	}
 
 	has, err := testEngine.Desc("id").Get(di)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.True(t, has)
-	}
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
 
 	has, err = testEngine.NoAutoCondition().Desc("id").Get(&di2)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, *di, di2)
-
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
-
-	if *di != di2 {
-		err = fmt.Errorf("%v is not equal to %v", di, di2)
-		t.Error(err)
-		panic(err)
-	}
-
-	/*if di2.Updated.Unix() != di.Updated.Unix() {
-		err = errors.New("updated should equal")
-		t.Error(err, di.Updated, di2.Updated)
-		panic(err)
-	}
-	if di2.Created.Unix() != di.Created.Unix() {
-		err = errors.New("created should equal")
-		t.Error(err, di.Created, di2.Created)
-		panic(err)
-	}*/
 }
 
 type CreatedInsert struct {
@@ -321,138 +258,82 @@ func TestInsertCreated(t *testing.T) {
 
 	di := new(CreatedInsert)
 	err := testEngine.Sync2(di)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci := &CreatedInsert{}
 	_, err = testEngine.Insert(ci)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	has, err := testEngine.Desc("id").Get(di)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci.Created.Unix(), di.Created.Unix())
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci.Created.Unix() != di.Created.Unix() {
-		t.Fatal("should equal:", ci, di)
-	}
-	fmt.Println("ci:", ci, "di:", di)
 
 	di2 := new(CreatedInsert2)
 	err = testEngine.Sync2(di2)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci2 := &CreatedInsert2{}
 	_, err = testEngine.Insert(ci2)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	has, err = testEngine.Desc("id").Get(di2)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci2.Created, di2.Created)
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci2.Created != di2.Created {
-		t.Fatal("should equal:", ci2, di2)
-	}
-	fmt.Println("ci2:", ci2, "di2:", di2)
 
 	di3 := new(CreatedInsert3)
 	err = testEngine.Sync2(di3)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci3 := &CreatedInsert3{}
 	_, err = testEngine.Insert(ci3)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	has, err = testEngine.Desc("id").Get(di3)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci3.Created, di3.Created)
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci3.Created != di3.Created {
-		t.Fatal("should equal:", ci3, di3)
-	}
-	fmt.Println("ci3:", ci3, "di3:", di3)
 
 	di4 := new(CreatedInsert4)
 	err = testEngine.Sync2(di4)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci4 := &CreatedInsert4{}
 	_, err = testEngine.Insert(ci4)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	has, err = testEngine.Desc("id").Get(di4)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci4.Created, di4.Created)
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci4.Created != di4.Created {
-		t.Fatal("should equal:", ci4, di4)
-	}
-	fmt.Println("ci4:", ci4, "di4:", di4)
 
 	di5 := new(CreatedInsert5)
 	err = testEngine.Sync2(di5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci5 := &CreatedInsert5{}
 	_, err = testEngine.Insert(ci5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	has, err = testEngine.Desc("id").Get(di5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci5.Created.Unix(), di5.Created.Unix())
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci5.Created.Unix() != di5.Created.Unix() {
-		t.Fatal("should equal:", ci5, di5)
-	}
-	fmt.Println("ci5:", ci5, "di5:", di5)
 
 	di6 := new(CreatedInsert6)
 	err = testEngine.Sync2(di6)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	oldTime := time.Now().Add(-time.Hour)
 	ci6 := &CreatedInsert6{Created: oldTime}
 	_, err = testEngine.Insert(ci6)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	has, err = testEngine.Desc("id").Get(di6)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci6.Created.Unix(), di6.Created.Unix())
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci6.Created.Unix() != di6.Created.Unix() {
-		t.Fatal("should equal:", ci6, di6)
-	}
-	fmt.Println("ci6:", ci6, "di6:", di6)
 }
 
 type JsonTime time.Time
@@ -509,25 +390,16 @@ func TestCreatedJsonTime(t *testing.T) {
 
 	di5 := new(MyJsonTime)
 	err := testEngine.Sync2(di5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci5 := &MyJsonTime{}
 	_, err = testEngine.Insert(ci5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	has, err := testEngine.Desc("id").Get(di5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix())
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if time.Time(ci5.Created).Unix() != time.Time(di5.Created).Unix() {
-		t.Fatal("should equal:", time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix())
-	}
-	fmt.Println("ci5:", ci5, "di5:", di5)
 
 	var dis = make([]MyJsonTime, 0)
 	err = testEngine.Find(&dis)
@@ -546,10 +418,7 @@ func TestInsertMulti2(t *testing.T) {
 		{Username: "xlw22", Departname: "dev", Alias: "lunny3", Created: time.Now()},
 	}
 	cnt, err := testEngine.Insert(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	assert.EqualValues(t, len(users), cnt)
 
 	users2 := []*Userinfo{
@@ -573,28 +442,10 @@ func TestInsertTwoTable(t *testing.T) {
 	userinfo := Userinfo{Username: "xlw3", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail}
 
 	cnt, err := testEngine.Insert(&userinfo, &userdetail)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.Greater(t, userinfo.Uid, int64(0))
-		panic(err)
+	assert.Greater(t, userdetail.Id, int64(0))
-	}
+	assert.EqualValues(t, 2, cnt)
-
-	if userinfo.Uid <= 0 {
-		err = errors.New("not return id error")
-		t.Error(err)
-		panic(err)
-	}
-
-	if userdetail.Id <= 0 {
-		err = errors.New("not return id error")
-		t.Error(err)
-		panic(err)
-	}
-
-	if cnt != 2 {
-		err = errors.New("insert not returned 2")
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestInsertCreatedInt64(t *testing.T) {

session_schema_test.go

@@ -260,16 +260,10 @@ func TestCharst(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables("user_charset")
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.Charset("utf8").Table("user_charset").CreateTable(&Userinfo{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestSync2_1(t *testing.T) {

session_tx_test.go

@@ -53,9 +53,7 @@ func TestCombineTransaction(t *testing.T) {
 
 	counter := func() {
 		total, err := testEngine.Count(&Userinfo{})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-		}
 		fmt.Printf("----now total %v records\n", total)
 	}
 
@@ -97,9 +95,7 @@ func TestCombineTransactionSameMapper(t *testing.T) {
 
 	counter := func() {
 		total, err := testEngine.Count(&Userinfo{})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-		}
 		fmt.Printf("----now total %v records\n", total)
 	}
 

session_update_test.go

@@ -5,7 +5,6 @@
 package xorm
 
 import (
-	"errors"
 	"fmt"
 	"sync"
 	"testing"
@@ -277,10 +276,7 @@ func TestUpdateMap2(t *testing.T) {
 	_, err := testEngine.Table("update_must_cols").Where("id =?", 1).Update(map[string]interface{}{
 		"bool": true,
 	})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestUpdate1(t *testing.T) {
@@ -293,14 +289,8 @@ func TestUpdate1(t *testing.T) {
 
 	var ori Userinfo
 	has, err := testEngine.Get(&ori)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.True(t, has)
-		panic(err)
-	}
-	if !has {
-		t.Error(errors.New("not exist"))
-		panic(errors.New("not exist"))
-	}
 
 	// update by id
 	user := Userinfo{Username: "xxx", Height: 1.2}
@@ -324,10 +314,7 @@ func TestUpdate1(t *testing.T) {
 	{
 		user := &Userinfo{Username: "not null data", Height: 180.5}
 		_, err := testEngine.Insert(user)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 		userID := user.Uid
 
 		has, err := testEngine.ID(userID).
@@ -337,29 +324,15 @@ func TestUpdate1(t *testing.T) {
 			And("detail_id = ?", 0).
 			And("is_man = ?", 0).
 			Get(&Userinfo{})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.True(t, has, "cannot insert properly")
-			panic(err)
-		}
-		if !has {
-			err = errors.New("cannot insert properly")
-			t.Error(err)
-			panic(err)
-		}
 
 		updatedUser := &Userinfo{Username: "null data"}
 		cnt, err = testEngine.ID(userID).
 			Nullable("height", "departname", "is_man", "created").
 			Update(updatedUser)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.EqualValues(t, 1, cnt, "update not returned 1")
-			panic(err)
-		}
-		if cnt != 1 {
-			err = errors.New("update not returned 1")
-			t.Error(err)
-			panic(err)
-		}
 
 		has, err = testEngine.ID(userID).
 			And("username = ?", updatedUser.Username).
@@ -369,60 +342,27 @@ func TestUpdate1(t *testing.T) {
 			And("created IS NULL").
 			And("detail_id = ?", 0).
 			Get(&Userinfo{})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.True(t, has, "cannot update with null properly")
-			panic(err)
-		}
-		if !has {
-			err = errors.New("cannot update with null properly")
-			t.Error(err)
-			panic(err)
-		}
 
 		cnt, err = testEngine.ID(userID).Delete(&Userinfo{})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.EqualValues(t, 1, cnt, "delete not returned 1")
-			panic(err)
-		}
-		if cnt != 1 {
-			err = errors.New("delete not returned 1")
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	err = testEngine.StoreEngine("Innodb").Sync2(&Article{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	defer func() {
 		err = testEngine.DropTables(&Article{})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 	}()
 
 	a := &Article{0, "1", "2", "3", "4", "5", 2}
 	cnt, err = testEngine.Insert(a)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, 1, cnt, fmt.Sprintf("insert not returned 1 but %d", cnt))
-		panic(err)
+	assert.Greater(t, a.Id, int32(0), "insert returned id is 0")
-	}
-
-	if cnt != 1 {
-		err = fmt.Errorf("insert not returned 1 but %d", cnt)
-		t.Error(err)
-		panic(err)
-	}
-
-	if a.Id == 0 {
-		err = errors.New("insert returned id is 0")
-		t.Error(err)
-		panic(err)
-	}
 
 	cnt, err = testEngine.ID(a.Id).Update(&Article{Name: "6"})
 	assert.NoError(t, err)
@@ -448,28 +388,18 @@ func TestUpdate1(t *testing.T) {
 	assert.EqualValues(t, *col2, *col3)
 
 	{
-
 		col1 := &UpdateMustCols{}
 		err = testEngine.Sync(col1)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 
 		_, err = testEngine.Insert(col1)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 
 		col2 := &UpdateMustCols{col1.Id, true, ""}
 		boolStr := testEngine.GetColumnMapper().Obj2Table("Bool")
 		stringStr := testEngine.GetColumnMapper().Obj2Table("String")
 		_, err = testEngine.ID(col2.Id).MustCols(boolStr, stringStr).Update(col2)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 
 		col3 := &UpdateMustCols{}
 		has, err := testEngine.ID(col2.Id).Get(col3)
@@ -547,32 +477,19 @@ func TestUpdateUpdated(t *testing.T) {
 
 	di := new(UpdatedUpdate)
 	err := testEngine.Sync2(di)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	_, err = testEngine.Insert(&UpdatedUpdate{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	ci := &UpdatedUpdate{}
 	_, err = testEngine.ID(1).Update(ci)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	has, err := testEngine.ID(1).Get(di)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci.Updated.Unix(), di.Updated.Unix())
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci.Updated.Unix() != di.Updated.Unix() {
-		t.Fatal("should equal:", ci, di)
-	}
-	fmt.Println("ci:", ci, "di:", di)
 
 	di2 := new(UpdatedUpdate2)
 	err = testEngine.Sync2(di2)
@@ -603,88 +520,51 @@ func TestUpdateUpdated(t *testing.T) {
 
 	di3 := new(UpdatedUpdate3)
 	err = testEngine.Sync2(di3)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	_, err = testEngine.Insert(&UpdatedUpdate3{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci3 := &UpdatedUpdate3{}
 	_, err = testEngine.ID(1).Update(ci3)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	has, err = testEngine.ID(1).Get(di3)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci3.Updated, di3.Updated)
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci3.Updated != di3.Updated {
-		t.Fatal("should equal:", ci3, di3)
-	}
-	fmt.Println("ci3:", ci3, "di3:", di3)
 
 	di4 := new(UpdatedUpdate4)
 	err = testEngine.Sync2(di4)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	_, err = testEngine.Insert(&UpdatedUpdate4{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	ci4 := &UpdatedUpdate4{}
 	_, err = testEngine.ID(1).Update(ci4)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	has, err = testEngine.ID(1).Get(di4)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci4.Updated, di4.Updated)
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci4.Updated != di4.Updated {
-		t.Fatal("should equal:", ci4, di4)
-	}
-	fmt.Println("ci4:", ci4, "di4:", di4)
 
 	di5 := new(UpdatedUpdate5)
 	err = testEngine.Sync2(di5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	_, err = testEngine.Insert(&UpdatedUpdate5{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+
-	}
 	ci5 := &UpdatedUpdate5{}
 	_, err = testEngine.ID(1).Update(ci5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	has, err = testEngine.ID(1).Get(di5)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Fatal(err)
+	assert.True(t, has)
-	}
+	assert.EqualValues(t, ci5.Updated.Unix(), di5.Updated.Unix())
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci5.Updated.Unix() != di5.Updated.Unix() {
-		t.Fatal("should equal:", ci5, di5)
-	}
-	fmt.Println("ci5:", ci5, "di5:", di5)
 }
 
 func TestUpdateSameMapper(t *testing.T) {
@@ -749,18 +629,8 @@ func TestUpdateSameMapper(t *testing.T) {
 	a := &Article{0, "1", "2", "3", "4", "5", 2}
 	cnt, err = testEngine.Insert(a)
 	assert.NoError(t, err)
-
+	assert.EqualValues(t, 1, cnt)
-	if cnt != 1 {
+	assert.Greater(t, a.Id, int32(0))
-		err = fmt.Errorf("insert not returned 1 but %d", cnt)
-		t.Error(err)
-		panic(err)
-	}
-
-	if a.Id == 0 {
-		err = errors.New("insert returned id is 0")
-		t.Error(err)
-		panic(err)
-	}
 
 	cnt, err = testEngine.ID(a.Id).Update(&Article{Name: "6"})
 	assert.NoError(t, err)
@@ -807,44 +677,20 @@ func TestUpdateSameMapper(t *testing.T) {
 	{
 		col1 := &UpdateIncr{}
 		err = testEngine.Sync(col1)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 
 		_, err = testEngine.Insert(col1)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 
 		cnt, err := testEngine.ID(col1.Id).Incr("`Cnt`").Update(col1)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.EqualValues(t, 1, cnt)
-			panic(err)
-		}
-		if cnt != 1 {
-			err = errors.New("update incr failed")
-			t.Error(err)
-			panic(err)
-		}
 
 		newCol := new(UpdateIncr)
 		has, err := testEngine.ID(col1.Id).Get(newCol)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.True(t, has)
-			panic(err)
+		assert.EqualValues(t, 1, newCol.Cnt)
-		}
-		if !has {
-			err = errors.New("has incr failed")
-			t.Error(err)
-			panic(err)
-		}
-		if 1 != newCol.Cnt {
-			err = errors.New("incr failed")
-			t.Error(err)
-			panic(err)
-		}
 	}
 }
 
@@ -853,17 +699,11 @@ func TestUseBool(t *testing.T) {
 	assertSync(t, new(Userinfo))
 
 	cnt1, err := testEngine.Count(&Userinfo{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	users := make([]Userinfo, 0)
 	err = testEngine.Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	var fNumber int64
 	for _, u := range users {
 		if u.IsMan == false {
@@ -872,10 +712,7 @@ func TestUseBool(t *testing.T) {
 	}
 
 	cnt2, err := testEngine.UseBool().Update(&Userinfo{IsMan: true})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	if fNumber != cnt2 {
 		fmt.Println("cnt1", cnt1, "fNumber", fNumber, "cnt2", cnt2)
 		/*err = errors.New("Updated number is not corrected.")
@@ -884,11 +721,7 @@ func TestUseBool(t *testing.T) {
 	}
 
 	_, err = testEngine.Update(&Userinfo{IsMan: true})
-	if err == nil {
+	assert.Error(t, err)
-		err = errors.New("error condition")
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestBool(t *testing.T) {
@@ -896,41 +729,21 @@ func TestBool(t *testing.T) {
 	assertSync(t, new(Userinfo))
 
 	_, err := testEngine.UseBool().Update(&Userinfo{IsMan: true})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	users := make([]Userinfo, 0)
 	err = testEngine.Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	for _, user := range users {
-		if !user.IsMan {
+		assert.True(t, user.IsMan)
-			err = errors.New("update bool or find bool error")
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	_, err = testEngine.UseBool().Update(&Userinfo{IsMan: false})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	users = make([]Userinfo, 0)
 	err = testEngine.Find(&users)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	for _, user := range users {
-		if user.IsMan {
+		assert.True(t, user.IsMan)
-			err = errors.New("update bool or find bool error")
-			t.Error(err)
-			panic(err)
-		}
 	}
 }
 
@@ -1452,3 +1265,41 @@ func TestUpdateMap3(t *testing.T) {
 	assert.Error(t, err)
 	assert.EqualValues(t, 0, rows)
 }
+
+func TestUpdateIgnoreOnlyFromDBFields(t *testing.T) {
+	type TestOnlyFromDBField struct {
+		Id              int64  `xorm:"PK"`
+		OnlyFromDBField string `xorm:"<-"`
+		OnlyToDBField   string `xorm:"->"`
+		IngoreField     string `xorm:"-"`
+	}
+
+	assertGetRecord := func() *TestOnlyFromDBField {
+		var record TestOnlyFromDBField
+		has, err := testEngine.Where("id = ?", 1).Get(&record)
+		assert.NoError(t, err)
+		assert.EqualValues(t, true, has)
+		assert.EqualValues(t, "", record.OnlyFromDBField)
+		return &record
+
+	}
+	assert.NoError(t, prepareEngine())
+	assertSync(t, new(TestOnlyFromDBField))
+
+	_, err := testEngine.Insert(&TestOnlyFromDBField{
+		Id:              1,
+		OnlyFromDBField: "a",
+		OnlyToDBField:   "b",
+		IngoreField:     "c",
+	})
+	assert.NoError(t, err)
+
+	assertGetRecord()
+
+	_, err = testEngine.ID(1).Update(&TestOnlyFromDBField{
+		OnlyToDBField:   "b",
+		OnlyFromDBField: "test",
+	})
+	assert.NoError(t, err)
+	assertGetRecord()
+}

statement_test.go

@@ -1,71 +0,0 @@
-// Copyright 2017 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package xorm
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestDistinctAndCols(t *testing.T) {
-	type DistinctAndCols struct {
-		Id   int64
-		Name string
-	}
-
-	assert.NoError(t, prepareEngine())
-	assertSync(t, new(DistinctAndCols))
-
-	cnt, err := testEngine.Insert(&DistinctAndCols{
-		Name: "test",
-	})
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, cnt)
-
-	var names []string
-	err = testEngine.Table("distinct_and_cols").Cols("name").Distinct("name").Find(&names)
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, len(names))
-	assert.EqualValues(t, "test", names[0])
-}
-
-func TestUpdateIgnoreOnlyFromDBFields(t *testing.T) {
-	type TestOnlyFromDBField struct {
-		Id              int64  `xorm:"PK"`
-		OnlyFromDBField string `xorm:"<-"`
-		OnlyToDBField   string `xorm:"->"`
-		IngoreField     string `xorm:"-"`
-	}
-
-	assertGetRecord := func() *TestOnlyFromDBField {
-		var record TestOnlyFromDBField
-		has, err := testEngine.Where("id = ?", 1).Get(&record)
-		assert.NoError(t, err)
-		assert.EqualValues(t, true, has)
-		assert.EqualValues(t, "", record.OnlyFromDBField)
-		return &record
-
-	}
-	assert.NoError(t, prepareEngine())
-	assertSync(t, new(TestOnlyFromDBField))
-
-	_, err := testEngine.Insert(&TestOnlyFromDBField{
-		Id:              1,
-		OnlyFromDBField: "a",
-		OnlyToDBField:   "b",
-		IngoreField:     "c",
-	})
-	assert.NoError(t, err)
-
-	assertGetRecord()
-
-	_, err = testEngine.ID(1).Update(&TestOnlyFromDBField{
-		OnlyToDBField:   "b",
-		OnlyFromDBField: "test",
-	})
-	assert.NoError(t, err)
-	assertGetRecord()
-}

tags_test.go

@@ -5,7 +5,6 @@
 package xorm
 
 import (
-	"errors"
 	"fmt"
 	"strings"
 	"testing"
@@ -275,25 +274,16 @@ func TestExtends3(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(&Message{}, &MessageUser{}, &MessageType{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.CreateTables(&Message{}, &MessageUser{}, &MessageType{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	var sender = MessageUser{Name: "sender"}
 	var receiver = MessageUser{Name: "receiver"}
 	var msgtype = MessageType{Name: "type"}
 	_, err = testEngine.Insert(&sender, &receiver, &msgtype)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	msg := Message{
 		MessageBase: MessageBase{
@@ -335,60 +325,29 @@ func TestExtends3(t *testing.T) {
 		Join("LEFT", []string{typeTableName, "type"}, "`type`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`").
 		Find(&list)
 	assert.NoError(t, err)
-
+	assert.EqualValues(t, 1, len(list))
-	if len(list) != 1 {
+	assert.EqualValues(t, list[0].Message.Id, msg.Id)
-		err = errors.New(fmt.Sprintln("should have 1 message, got", len(list)))
+	assert.EqualValues(t, list[0].Sender.Id, sender.Id)
-		t.Error(err)
+	assert.EqualValues(t, list[0].Sender.Name, sender.Name)
-		panic(err)
+	assert.EqualValues(t, list[0].Receiver.Id, receiver.Id)
-	}
+	assert.EqualValues(t, list[0].Receiver.Name, receiver.Name)
-
+	assert.EqualValues(t, list[0].Type.Id, msgtype.Id)
-	if list[0].Message.Id != msg.Id {
+	assert.EqualValues(t, list[0].Type.Name, msgtype.Name)
-		err = errors.New(fmt.Sprintln("should message equal", list[0].Message, msg))
-		t.Error(err)
-		panic(err)
-	}
-
-	if list[0].Sender.Id != sender.Id || list[0].Sender.Name != sender.Name {
-		err = errors.New(fmt.Sprintln("should sender equal", list[0].Sender, sender))
-		t.Error(err)
-		panic(err)
-	}
-
-	if list[0].Receiver.Id != receiver.Id || list[0].Receiver.Name != receiver.Name {
-		err = errors.New(fmt.Sprintln("should receiver equal", list[0].Receiver, receiver))
-		t.Error(err)
-		panic(err)
-	}
-
-	if list[0].Type.Id != msgtype.Id || list[0].Type.Name != msgtype.Name {
-		err = errors.New(fmt.Sprintln("should msgtype equal", list[0].Type, msgtype))
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestExtends4(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(&Message{}, &MessageUser{}, &MessageType{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.CreateTables(&Message{}, &MessageUser{}, &MessageType{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	var sender = MessageUser{Name: "sender"}
 	var msgtype = MessageType{Name: "type"}
 	_, err = testEngine.Insert(&sender, &msgtype)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	msg := Message{
 		MessageBase: MessageBase{
@@ -427,34 +386,13 @@ func TestExtends4(t *testing.T) {
 	err = session.Table(msgTableName).Join("LEFT", userTableName, userTableName+".`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`").
 		Join("LEFT", typeTableName, typeTableName+".`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`").
 		Find(&list)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, len(list), 1)
-		panic(err)
+	assert.EqualValues(t, list[0].Message.Id, msg.Id)
-	}
+	assert.EqualValues(t, list[0].MessageUser.Id, sender.Id)
-
+	assert.EqualValues(t, list[0].MessageUser.Name, sender.Name)
-	if len(list) != 1 {
+	assert.EqualValues(t, list[0].MessageType.Id, msgtype.Id)
-		err = errors.New(fmt.Sprintln("should have 1 message, got", len(list)))
+	assert.EqualValues(t, list[0].MessageType.Name, msgtype.Name)
-		t.Error(err)
-		panic(err)
-	}
-
-	if list[0].Message.Id != msg.Id {
-		err = errors.New(fmt.Sprintln("should message equal", list[0].Message, msg))
-		t.Error(err)
-		panic(err)
-	}
-
-	if list[0].MessageUser.Id != sender.Id || list[0].MessageUser.Name != sender.Name {
-		err = errors.New(fmt.Sprintln("should sender equal", list[0].MessageUser, sender))
-		t.Error(err)
-		panic(err)
-	}
-
-	if list[0].MessageType.Id != msgtype.Id || list[0].MessageType.Name != msgtype.Name {
-		err = errors.New(fmt.Sprintln("should msgtype equal", list[0].MessageType, msgtype))
-		t.Error(err)
-		panic(err)
-	}
 }
 
 type Size struct {
@@ -473,16 +411,10 @@ type Book struct {
 func TestExtends5(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	err := testEngine.DropTables(&Book{}, &Size{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.CreateTables(&Size{}, &Book{})
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	var sc = Size{Width: 0.2, Height: 0.4}
 	var so = Size{Width: 0.2, Height: 0.8}
@@ -547,10 +479,7 @@ func TestExtends5(t *testing.T) {
 			bookTableName+".`Size`=s.`id`",
 		).
 		Find(&list)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	for _, book := range list {
 		if ok := assert.Equal(t, books[book.ID].SizeClosed.Width, book.SizeClosed.Width); !ok {
@@ -1262,106 +1191,50 @@ func TestVersion1(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(new(VersionS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.CreateTables(new(VersionS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	ver := &VersionS{Name: "sfsfdsfds"}
 	_, err = testEngine.Insert(ver)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, ver.Ver, 1)
-		panic(err)
-	}
-	fmt.Println(ver)
-	if ver.Ver != 1 {
-		err = errors.New("insert error")
-		t.Error(err)
-		panic(err)
-	}
 
 	newVer := new(VersionS)
 	has, err := testEngine.ID(ver.Id).Get(newVer)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.True(t, has)
-		panic(err)
+	assert.EqualValues(t, newVer.Ver, 1)
-	}
-
-	if !has {
-		t.Error(fmt.Errorf("no version id is %v", ver.Id))
-		panic(err)
-	}
-	fmt.Println(newVer)
-	if newVer.Ver != 1 {
-		err = errors.New("insert error")
-		t.Error(err)
-		panic(err)
-	}
 
 	newVer.Name = "-------"
 	_, err = testEngine.ID(ver.Id).Update(newVer)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, newVer.Ver, 2)
-		panic(err)
-	}
-	if newVer.Ver != 2 {
-		err = errors.New("update should set version back to struct")
-		t.Error(err)
-	}
 
 	newVer = new(VersionS)
 	has, err = testEngine.ID(ver.Id).Get(newVer)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, newVer.Ver, 2)
-		panic(err)
-	}
-	fmt.Println(newVer)
-	if newVer.Ver != 2 {
-		err = errors.New("update error")
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestVersion2(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(new(VersionS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.CreateTables(new(VersionS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	var vers = []VersionS{
 		{Name: "sfsfdsfds"},
 		{Name: "xxxxx"},
 	}
 	_, err = testEngine.Insert(vers)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
-
-	fmt.Println(vers)
-
 	for _, v := range vers {
-		if v.Ver != 1 {
+		assert.EqualValues(t, v.Ver, 1)
-			err := errors.New("version should be 1")
-			t.Error(err)
-			panic(err)
-		}
 	}
 }
 
@@ -1376,105 +1249,49 @@ func TestVersion3(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(new(VersionUintS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.CreateTables(new(VersionUintS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	ver := &VersionUintS{Name: "sfsfdsfds"}
 	_, err = testEngine.Insert(ver)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, ver.Ver, 1)
-		panic(err)
-	}
-	fmt.Println(ver)
-	if ver.Ver != 1 {
-		err = errors.New("insert error")
-		t.Error(err)
-		panic(err)
-	}
 
 	newVer := new(VersionUintS)
 	has, err := testEngine.ID(ver.Id).Get(newVer)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.True(t, has)
-		panic(err)
+	assert.EqualValues(t, newVer.Ver, 1)
-	}
-
-	if !has {
-		t.Error(fmt.Errorf("no version id is %v", ver.Id))
-		panic(err)
-	}
-	fmt.Println(newVer)
-	if newVer.Ver != 1 {
-		err = errors.New("insert error")
-		t.Error(err)
-		panic(err)
-	}
 
 	newVer.Name = "-------"
 	_, err = testEngine.ID(ver.Id).Update(newVer)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, newVer.Ver, 2)
-		panic(err)
-	}
-	if newVer.Ver != 2 {
-		err = errors.New("update should set version back to struct")
-		t.Error(err)
-	}
 
 	newVer = new(VersionUintS)
 	has, err = testEngine.ID(ver.Id).Get(newVer)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
+	assert.EqualValues(t, newVer.Ver, 2)
-		panic(err)
-	}
-	fmt.Println(newVer)
-	if newVer.Ver != 2 {
-		err = errors.New("update error")
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestVersion4(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(new(VersionUintS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	err = testEngine.CreateTables(new(VersionUintS))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	var vers = []VersionUintS{
 		{Name: "sfsfdsfds"},
 		{Name: "xxxxx"},
 	}
 	_, err = testEngine.Insert(vers)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
-
-	fmt.Println(vers)
-
 	for _, v := range vers {
-		if v.Ver != 1 {
+		assert.EqualValues(t, v.Ver, 1)
-			err := errors.New("version should be 1")
-			t.Error(err)
-			panic(err)
-		}
 	}
 }

time_test.go

@@ -10,10 +10,15 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
 	"xorm.io/xorm/internal/utils"
+
+	"github.com/stretchr/testify/assert"
 )
 
+func formatTime(t time.Time) string {
+	return t.Format("2006-01-02 15:04:05")
+}
+
 func TestTimeUserTime(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 

transaction.go

@@ -1,26 +0,0 @@
-// Copyright 2018 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package xorm
-
-// Transaction Execute sql wrapped in a transaction(abbr as tx), tx will automatic commit if no errors occurred
-func (engine *Engine) Transaction(f func(*Session) (interface{}, error)) (interface{}, error) {
-	session := engine.NewSession()
-	defer session.Close()
-
-	if err := session.Begin(); err != nil {
-		return nil, err
-	}
-
-	result, err := f(session)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := session.Commit(); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}

types_null_test.go

@@ -60,20 +60,14 @@ func TestCreateNullStructTable(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.CreateTables(new(NullType))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestDropNullStructTable(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(new(NullType))
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 }
 
 func TestNullStructInsert(t *testing.T) {
@@ -83,16 +77,8 @@ func TestNullStructInsert(t *testing.T) {
 	if true {
 		item := new(NullType)
 		_, err := testEngine.Insert(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.EqualValues(t, item.Id, 1)
-			panic(err)
-		}
-		fmt.Println(item)
-		if item.Id != 1 {
-			err = errors.New("insert error")
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	if true {
@@ -103,16 +89,8 @@ func TestNullStructInsert(t *testing.T) {
 			IsMan:  sql.NullBool{Bool: true, Valid: true},
 		}
 		_, err := testEngine.Insert(&item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.EqualValues(t, item.Id, 2)
-			panic(err)
-		}
-		fmt.Println(item)
-		if item.Id != 2 {
-			err = errors.New("insert error")
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	if true {
@@ -131,11 +109,7 @@ func TestNullStructInsert(t *testing.T) {
 		}
 
 		_, err := testEngine.Insert(&items)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
-		fmt.Println(items)
 	}
 }
 
@@ -177,30 +151,16 @@ func TestNullStructUpdate(t *testing.T) {
 		item.Height = sql.NullFloat64{Float64: 0, Valid: false} // update to NULL
 
 		affected, err := testEngine.ID(2).Cols("age", "height", "is_man").Update(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.EqualValues(t, affected, 1)
-			panic(err)
-		}
-		if affected != 1 {
-			err := errors.New("update failed")
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	if true { // 测试In update
 		item := new(NullType)
 		item.Age = sql.NullInt64{Int64: 23, Valid: true}
 		affected, err := testEngine.In("id", 3, 4).Cols("age", "height", "is_man").Update(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.EqualValues(t, affected, 2)
-			panic(err)
-		}
-		if affected != 2 {
-			err := errors.New("update failed")
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	if true { // 测试where
@@ -210,10 +170,7 @@ func TestNullStructUpdate(t *testing.T) {
 		item.Age = sql.NullInt64{Int64: 34, Valid: true}
 
 		_, err := testEngine.Where("age > ?", 34).Update(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	if true { // 修改全部时，插入空值
@@ -225,10 +182,7 @@ func TestNullStructUpdate(t *testing.T) {
 		}
 
 		_, err := testEngine.AllCols().ID(6).Update(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 		fmt.Println(item)
 	}
 
@@ -269,63 +223,33 @@ func TestNullStructFind(t *testing.T) {
 	if true {
 		item := new(NullType)
 		has, err := testEngine.ID(1).Get(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.True(t, has)
-			panic(err)
+		assert.EqualValues(t, item.Id, 1)
-		}
+		assert.False(t, item.Name.Valid)
-		if !has {
+		assert.False(t, item.Age.Valid)
-			t.Error(errors.New("no find id 1"))
+		assert.False(t, item.Height.Valid)
-			panic(err)
+		assert.False(t, item.IsMan.Valid)
-		}
-		fmt.Println(item)
-		if item.Id != 1 || item.Name.Valid || item.Age.Valid || item.Height.Valid ||
-			item.IsMan.Valid {
-			err = errors.New("insert error")
-			t.Error(err)
-			panic(err)
-		}
 	}
 
 	if true {
 		item := new(NullType)
 		item.Id = 2
-
 		has, err := testEngine.Get(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.True(t, has)
-			panic(err)
-		}
-		if !has {
-			t.Error(errors.New("no find id 2"))
-			panic(err)
-		}
-		fmt.Println(item)
 	}
 
 	if true {
 		item := make([]NullType, 0)
-
 		err := testEngine.ID(2).Find(&item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
-
-		fmt.Println(item)
 	}
 
 	if true {
 		item := make([]NullType, 0)
-
 		err := testEngine.Asc("age").Find(&item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
-
-		for k, v := range item {
-			fmt.Println(k, v)
-		}
 	}
 }
 
@@ -340,10 +264,7 @@ func TestNullStructIterate(t *testing.T) {
 				fmt.Println(i, nultype)
 				return nil
 			})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 	}
 }
 
@@ -354,10 +275,7 @@ func TestNullStructCount(t *testing.T) {
 	if true {
 		item := new(NullType)
 		total, err := testEngine.Where("age IS NOT NULL").Count(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 		fmt.Println(total)
 	}
 }
@@ -368,18 +286,12 @@ func TestNullStructRows(t *testing.T) {
 
 	item := new(NullType)
 	rows, err := testEngine.Where("id > ?", 1).Rows(item)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 	defer rows.Close()
 
 	for rows.Next() {
 		err = rows.Scan(item)
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
-			panic(err)
-		}
 		fmt.Println(item)
 	}
 }
@@ -391,14 +303,8 @@ func TestNullStructDelete(t *testing.T) {
 	item := new(NullType)
 
 	_, err := testEngine.ID(1).Delete(item)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 
 	_, err = testEngine.Where("id > ?", 1).Delete(item)
-	if err != nil {
+	assert.NoError(t, err)
-		t.Error(err)
-		panic(err)
-	}
 }