xorm/xorm
xorm/xorm
63
356
Fork 206
Code Issues 372 Pull Requests 19 Actions Releases 35 Activity

Improve tests #1572

Merged
lunny merged 2 commits from lunny/improve_tests2 into master 2020-03-04 03:30:26 +00:00
Conversation 0 Commits 2 Files Changed 28 +738 -2095
28 changed files with 738 additions and 2095 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
caches/leveldb.go
View File

@ -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 {
panic(err)
} else {
db.store = h
h, err := leveldb.OpenFile(dbfile, nil)
if err != nil {
return nil, err
}
return db
db.store = h
return db, nil
}
func (s *LevelDBStore) Put(key string, value interface{}) error {

4
caches/leveldb_test.go
View File

@ -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",
}

125
convert.go
View File

@ -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()
}

40
engine.go
View File

@ -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
}

28
engine_context.go
View File

@ -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)
}

28
engine_context_test.go
View File

@ -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")
}

14
transancation_test.go → engine_test.go
View File

@ -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())

10
error.go
View File

@ -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)
}

163
helpers.go
View File

@ -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")
}

6
internal/statements/update.go
View File

@ -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?
panic("not supported")
return nil, nil, errors.New("Not supported multiple primary keys")
}
}
} 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)

58
processors_test.go
View File

@ -125,17 +125,11 @@ func TestProcessors(t *testing.T) {
assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&ProcessorsStruct{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
p := &ProcessorsStruct{}
err = testEngine.CreateTables(&ProcessorsStruct{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p.AfterUpdatedFlag == 0 {
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"))
}
assert.False(t, p.B4UpdateFlag == 0, "B4UpdateFlag not set")
assert.False(t, p.AfterUpdatedFlag == 0, "AfterUpdatedFlag not set")
assert.False(t, p.B4UpdateViaExt == 0, "B4UpdateViaExt not set")
assert.False(t, p.AfterUpdatedViaExt == 0, "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 {
t.Error(errors.New("B4UpdateFlag not set"))
}
if p2.AfterUpdatedFlag != 0 {
t.Error(errors.New("AfterUpdatedFlag is set: " + string(p.AfterUpdatedFlag)))
}
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))
}
assert.False(t, p2.B4UpdateFlag == 0, "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")
assert.False(t, p2.AfterUpdatedViaExt != 0, fmt.Sprintf("AfterUpdatedViaExt is set: %d", p.AfterUpdatedViaExt))
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))
// --
// 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)
if p2.Id > 0 {
err = errors.New("tx got committed upon insert!?")
t.Error(err)
panic(err)
}
assert.False(t, p2.Id > 0, "tx got committed upon insert!?")
// --
// 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 {

26
session.go
View File

@ -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)
}

4
session_cond_test.go
View File

@ -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)

23
session_context.go
View File

@ -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)
}

36
session_context_test.go
View File

@ -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)
}

3
session_delete_test.go
View File

@ -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) {

25
session_exist_test.go
View File

@ -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)
}

140
session_find_test.go
View File

@ -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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
fmt.Println(users)
err = testEngine.Where("id > ?", 2).And("id < ?", 10).Find(&users)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
for _, user := range users {
fmt.Println(user)
}
assert.NoError(t, err)
}
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 {
t.Error(err)
panic(err)
}
for id, user := range users {
fmt.Println(id, user)
}
assert.NoError(t, err)
}
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 {
fmt.Println(len(users2))
t.Error(err)
panic(errors.New("should be one record"))
}
fmt.Println(users2)
assert.EqualValues(t, 1, len(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 {
t.Fatal(err)
}
fmt.Println(users)
assert.NoError(t, err)
}
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 {
t.Fatal(err)
}
fmt.Println(idsInt64)
assert.NoError(t, err)
var idsInt32 []int32
err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsInt32)
if err != nil {
t.Fatal(err)
}
fmt.Println(idsInt32)
assert.NoError(t, err)
var idsInt []int
err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsInt)
if err != nil {
t.Fatal(err)
}
fmt.Println(idsInt)
assert.NoError(t, err)
var idsUint []uint
err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsUint)
if err != nil {
t.Fatal(err)
}
fmt.Println(idsUint)
assert.NoError(t, err)
type MyInt int
var idsMyInt []MyInt
err = testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsMyInt)
if err != nil {
t.Fatal(err)
}
fmt.Println(idsMyInt)
assert.NoError(t, err)
}
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 {
t.Fatal(err)
}
fmt.Println(idsString)
assert.NoError(t, err)
}
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 {
t.Fatal(err)
}
fmt.Println(idsMyString)
assert.NoError(t, err)
}
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 {
t.Fatal(err)
}
fmt.Println(idsInterface)
assert.NoError(t, err)
}
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 {
t.Fatal(err)
}
for _, record := range ids {
fmt.Println(record)
}
assert.NoError(t, err)
}
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 {
t.Fatal(err)
}
for _, record := range ids {
fmt.Println(record)
}
assert.NoError(t, err)
}
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 {
t.Fatal(err)
}
for _, record := range ids {
fmt.Println(record)
}
assert.NoError(t, err)
}
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])
}

281
session_insert_test.go
View File

@ -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)
if err != nil {
t.Error(err)
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"))
}
assert.NoError(t, err)
assert.EqualValues(t, 1, cnt)
assert.Greater(t, user.Uid, int64(0))
}
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 {
err = errors.New("error with no data")
t.Error(err)
panic(err)
}
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)
}
assert.True(t, has)
assert.EqualValues(t, -1, di.Status)
assert.EqualValues(t, di2.Updated.Unix(), di.Updated.Unix())
assert.EqualValues(t, di2.Created.Unix(), di.Created.Unix())
}
type DefaultInsert2 struct {
@ -237,53 +207,20 @@ func TestInsertDefault2(t *testing.T) {
di := new(DefaultInsert2)
err := testEngine.Sync2(di)
if err != nil {
t.Error(err)
}
assert.NoError(t, err)
var di2 = DefaultInsert2{Name: "test"}
_, err = testEngine.Omit(testEngine.GetColumnMapper().Obj2Table("CheckTime")).Insert(&di2)
if err != nil {
t.Error(err)
}
assert.NoError(t, err)
has, err := testEngine.Desc("id").Get(di)
if err != nil {
t.Error(err)
}
if !has {
err = errors.New("error with no data")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.True(t, has)
has, err = testEngine.NoAutoCondition().Desc("id").Get(&di2)
if err != nil {
t.Error(err)
}
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)
}*/
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, *di, di2)
}
type CreatedInsert struct {
@ -321,138 +258,82 @@ func TestInsertCreated(t *testing.T) {
di := new(CreatedInsert)
err := testEngine.Sync2(di)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci := &CreatedInsert{}
_, err = testEngine.Insert(ci)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err := testEngine.Desc("id").Get(di)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci.Created.Unix() != di.Created.Unix() {
t.Fatal("should equal:", ci, di)
}
fmt.Println("ci:", ci, "di:", di)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci.Created.Unix(), di.Created.Unix())
di2 := new(CreatedInsert2)
err = testEngine.Sync2(di2)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci2 := &CreatedInsert2{}
_, err = testEngine.Insert(ci2)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.Desc("id").Get(di2)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci2.Created != di2.Created {
t.Fatal("should equal:", ci2, di2)
}
fmt.Println("ci2:", ci2, "di2:", di2)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci2.Created, di2.Created)
di3 := new(CreatedInsert3)
err = testEngine.Sync2(di3)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci3 := &CreatedInsert3{}
_, err = testEngine.Insert(ci3)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.Desc("id").Get(di3)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci3.Created != di3.Created {
t.Fatal("should equal:", ci3, di3)
}
fmt.Println("ci3:", ci3, "di3:", di3)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci3.Created, di3.Created)
di4 := new(CreatedInsert4)
err = testEngine.Sync2(di4)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci4 := &CreatedInsert4{}
_, err = testEngine.Insert(ci4)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.Desc("id").Get(di4)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci4.Created != di4.Created {
t.Fatal("should equal:", ci4, di4)
}
fmt.Println("ci4:", ci4, "di4:", di4)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci4.Created, di4.Created)
di5 := new(CreatedInsert5)
err = testEngine.Sync2(di5)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci5 := &CreatedInsert5{}
_, err = testEngine.Insert(ci5)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.Desc("id").Get(di5)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci5.Created.Unix() != di5.Created.Unix() {
t.Fatal("should equal:", ci5, di5)
}
fmt.Println("ci5:", ci5, "di5:", di5)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci5.Created.Unix(), di5.Created.Unix())
di6 := new(CreatedInsert6)
err = testEngine.Sync2(di6)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
oldTime := time.Now().Add(-time.Hour)
ci6 := &CreatedInsert6{Created: oldTime}
_, err = testEngine.Insert(ci6)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.Desc("id").Get(di6)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci6.Created.Unix() != di6.Created.Unix() {
t.Fatal("should equal:", ci6, di6)
}
fmt.Println("ci6:", ci6, "di6:", di6)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci6.Created.Unix(), di6.Created.Unix())
}
type JsonTime time.Time
@ -509,25 +390,16 @@ func TestCreatedJsonTime(t *testing.T) {
di5 := new(MyJsonTime)
err := testEngine.Sync2(di5)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci5 := &MyJsonTime{}
_, err = testEngine.Insert(ci5)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err := testEngine.Desc("id").Get(di5)
if err != nil {
t.Fatal(err)
}
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)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix())
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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
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)
}
assert.NoError(t, err)
assert.Greater(t, userinfo.Uid, int64(0))
assert.Greater(t, userdetail.Id, int64(0))
assert.EqualValues(t, 2, cnt)
}
func TestInsertCreatedInt64(t *testing.T) {

885
session_pk_test.go
View File

File diff suppressed because it is too large Load Diff

10
session_schema_test.go
View File

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

8
session_tx_test.go
View File

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

355
session_update_test.go
View File

@ -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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
if !has {
t.Error(errors.New("not exist"))
panic(errors.New("not exist"))
}
assert.NoError(t, err)
assert.True(t, has)
// 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
if !has {
err = errors.New("cannot insert properly")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.True(t, has, "cannot insert properly")
updatedUser := &Userinfo{Username: "null data"}
cnt, err = testEngine.ID(userID).
Nullable("height", "departname", "is_man", "created").
Update(updatedUser)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("update not returned 1")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, 1, cnt, "update not returned 1")
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 {
t.Error(err)
panic(err)
}
if !has {
err = errors.New("cannot update with null properly")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.True(t, has, "cannot update with null properly")
cnt, err = testEngine.ID(userID).Delete(&Userinfo{})
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("delete not returned 1")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, 1, cnt, "delete not returned 1")
}
err = testEngine.StoreEngine("Innodb").Sync2(&Article{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
defer func() {
err = testEngine.DropTables(&Article{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
}()
a := &Article{0, "1", "2", "3", "4", "5", 2}
cnt, err = testEngine.Insert(a)
if err != nil {
t.Error(err)
panic(err)
}
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)
}
assert.NoError(t, err)
assert.EqualValues(t, 1, cnt, fmt.Sprintf("insert not returned 1 but %d", cnt))
assert.Greater(t, a.Id, int32(0), "insert returned id is 0")
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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
_, err = testEngine.Insert(col1)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Fatal(err)
}
assert.NoError(t, err)
_, err = testEngine.Insert(&UpdatedUpdate{})
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci := &UpdatedUpdate{}
_, err = testEngine.ID(1).Update(ci)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err := testEngine.ID(1).Get(di)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci.Updated.Unix() != di.Updated.Unix() {
t.Fatal("should equal:", ci, di)
}
fmt.Println("ci:", ci, "di:", di)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci.Updated.Unix(), di.Updated.Unix())
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 {
t.Fatal(err)
}
assert.NoError(t, err)
_, err = testEngine.Insert(&UpdatedUpdate3{})
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci3 := &UpdatedUpdate3{}
_, err = testEngine.ID(1).Update(ci3)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.ID(1).Get(di3)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci3.Updated != di3.Updated {
t.Fatal("should equal:", ci3, di3)
}
fmt.Println("ci3:", ci3, "di3:", di3)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci3.Updated, di3.Updated)
di4 := new(UpdatedUpdate4)
err = testEngine.Sync2(di4)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
_, err = testEngine.Insert(&UpdatedUpdate4{})
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci4 := &UpdatedUpdate4{}
_, err = testEngine.ID(1).Update(ci4)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.ID(1).Get(di4)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci4.Updated != di4.Updated {
t.Fatal("should equal:", ci4, di4)
}
fmt.Println("ci4:", ci4, "di4:", di4)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci4.Updated, di4.Updated)
di5 := new(UpdatedUpdate5)
err = testEngine.Sync2(di5)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
_, err = testEngine.Insert(&UpdatedUpdate5{})
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
ci5 := &UpdatedUpdate5{}
_, err = testEngine.ID(1).Update(ci5)
if err != nil {
t.Fatal(err)
}
assert.NoError(t, err)
has, err = testEngine.ID(1).Get(di5)
if err != nil {
t.Fatal(err)
}
if !has {
t.Fatal(ErrNotExist)
}
if ci5.Updated.Unix() != di5.Updated.Unix() {
t.Fatal("should equal:", ci5, di5)
}
fmt.Println("ci5:", ci5, "di5:", di5)
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, ci5.Updated.Unix(), di5.Updated.Unix())
}
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)
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)
}
assert.EqualValues(t, 1, cnt)
assert.Greater(t, a.Id, int32(0))
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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
_, err = testEngine.Insert(col1)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
cnt, err := testEngine.ID(col1.Id).Incr("`Cnt`").Update(col1)
if err != nil {
t.Error(err)
panic(err)
}
if cnt != 1 {
err = errors.New("update incr failed")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, 1, cnt)
newCol := new(UpdateIncr)
has, err := testEngine.ID(col1.Id).Get(newCol)
if err != nil {
t.Error(err)
panic(err)
}
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)
}
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, 1, newCol.Cnt)
}
}
@ -853,17 +699,11 @@ func TestUseBool(t *testing.T) {
assertSync(t, new(Userinfo))
cnt1, err := testEngine.Count(&Userinfo{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
users := make([]Userinfo, 0)
err = testEngine.Find(&users)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
err = errors.New("error condition")
t.Error(err)
panic(err)
}
assert.Error(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
users := make([]Userinfo, 0)
err = testEngine.Find(&users)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
for _, user := range users {
if !user.IsMan {
err = errors.New("update bool or find bool error")
t.Error(err)
panic(err)
}
assert.True(t, user.IsMan)
}
_, err = testEngine.UseBool().Update(&Userinfo{IsMan: false})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
users = make([]Userinfo, 0)
err = testEngine.Find(&users)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
for _, user := range users {
if user.IsMan {
err = errors.New("update bool or find bool error")
t.Error(err)
panic(err)
}
assert.True(t, user.IsMan)
}
}
@ -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()
}

71
statement_test.go
View File

@ -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()
}

291
tags_test.go
View File

@ -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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
err = testEngine.CreateTables(&Message{}, &MessageUser{}, &MessageType{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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)
if len(list) != 1 {
err = errors.New(fmt.Sprintln("should have 1 message, got", len(list)))
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].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)
}
assert.EqualValues(t, 1, len(list))
assert.EqualValues(t, list[0].Message.Id, msg.Id)
assert.EqualValues(t, list[0].Sender.Id, sender.Id)
assert.EqualValues(t, list[0].Sender.Name, sender.Name)
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)
assert.EqualValues(t, list[0].Type.Name, msgtype.Name)
}
func TestExtends4(t *testing.T) {
assert.NoError(t, prepareEngine())
err := testEngine.DropTables(&Message{}, &MessageUser{}, &MessageType{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
err = testEngine.CreateTables(&Message{}, &MessageUser{}, &MessageType{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
var sender = MessageUser{Name: "sender"}
var msgtype = MessageType{Name: "type"}
_, err = testEngine.Insert(&sender, &msgtype)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
if len(list) != 1 {
err = errors.New(fmt.Sprintln("should have 1 message, got", len(list)))
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)
}
assert.NoError(t, err)
assert.EqualValues(t, len(list), 1)
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)
assert.EqualValues(t, list[0].MessageType.Id, msgtype.Id)
assert.EqualValues(t, list[0].MessageType.Name, msgtype.Name)
}
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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
err = testEngine.CreateTables(&Size{}, &Book{})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
err = testEngine.CreateTables(new(VersionS))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
ver := &VersionS{Name: "sfsfdsfds"}
_, err = testEngine.Insert(ver)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(ver)
if ver.Ver != 1 {
err = errors.New("insert error")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, ver.Ver, 1)
newVer := new(VersionS)
has, err := testEngine.ID(ver.Id).Get(newVer)
if err != nil {
t.Error(err)
panic(err)
}
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)
}
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, newVer.Ver, 1)
newVer.Name = "-------"
_, err = testEngine.ID(ver.Id).Update(newVer)
if err != nil {
t.Error(err)
panic(err)
}
if newVer.Ver != 2 {
err = errors.New("update should set version back to struct")
t.Error(err)
}
assert.NoError(t, err)
assert.EqualValues(t, newVer.Ver, 2)
newVer = new(VersionS)
has, err = testEngine.ID(ver.Id).Get(newVer)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(newVer)
if newVer.Ver != 2 {
err = errors.New("update error")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, newVer.Ver, 2)
}
func TestVersion2(t *testing.T) {
assert.NoError(t, prepareEngine())
err := testEngine.DropTables(new(VersionS))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
err = testEngine.CreateTables(new(VersionS))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
var vers = []VersionS{
{Name: "sfsfdsfds"},
{Name: "xxxxx"},
}
_, err = testEngine.Insert(vers)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(vers)
assert.NoError(t, err)
for _, v := range vers {
if v.Ver != 1 {
err := errors.New("version should be 1")
t.Error(err)
panic(err)
}
assert.EqualValues(t, v.Ver, 1)
}
}
@ -1376,105 +1249,49 @@ func TestVersion3(t *testing.T) {
assert.NoError(t, prepareEngine())
err := testEngine.DropTables(new(VersionUintS))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
err = testEngine.CreateTables(new(VersionUintS))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
ver := &VersionUintS{Name: "sfsfdsfds"}
_, err = testEngine.Insert(ver)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(ver)
if ver.Ver != 1 {
err = errors.New("insert error")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, ver.Ver, 1)
newVer := new(VersionUintS)
has, err := testEngine.ID(ver.Id).Get(newVer)
if err != nil {
t.Error(err)
panic(err)
}
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)
}
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, newVer.Ver, 1)
newVer.Name = "-------"
_, err = testEngine.ID(ver.Id).Update(newVer)
if err != nil {
t.Error(err)
panic(err)
}
if newVer.Ver != 2 {
err = errors.New("update should set version back to struct")
t.Error(err)
}
assert.NoError(t, err)
assert.EqualValues(t, newVer.Ver, 2)
newVer = new(VersionUintS)
has, err = testEngine.ID(ver.Id).Get(newVer)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(newVer)
if newVer.Ver != 2 {
err = errors.New("update error")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, newVer.Ver, 2)
}
func TestVersion4(t *testing.T) {
assert.NoError(t, prepareEngine())
err := testEngine.DropTables(new(VersionUintS))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
err = testEngine.CreateTables(new(VersionUintS))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
var vers = []VersionUintS{
{Name: "sfsfdsfds"},
{Name: "xxxxx"},
}
_, err = testEngine.Insert(vers)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(vers)
assert.NoError(t, err)
for _, v := range vers {
if v.Ver != 1 {
err := errors.New("version should be 1")
t.Error(err)
panic(err)
}
assert.EqualValues(t, v.Ver, 1)
}
}

7
time_test.go
View File

@ -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())

26
transaction.go
View File

@ -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
}

154
types_null_test.go
View File

@ -60,20 +60,14 @@ func TestCreateNullStructTable(t *testing.T) {
assert.NoError(t, prepareEngine())
err := testEngine.CreateTables(new(NullType))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
}
func TestDropNullStructTable(t *testing.T) {
assert.NoError(t, prepareEngine())
err := testEngine.DropTables(new(NullType))
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
fmt.Println(item)
if item.Id != 1 {
err = errors.New("insert error")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, item.Id, 1)
}
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 {
t.Error(err)
panic(err)
}
fmt.Println(item)
if item.Id != 2 {
err = errors.New("insert error")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, item.Id, 2)
}
if true {
@ -131,11 +109,7 @@ func TestNullStructInsert(t *testing.T) {
}
_, err := testEngine.Insert(&items)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(items)
assert.NoError(t, err)
}
}
@ -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 {
t.Error(err)
panic(err)
}
if affected != 1 {
err := errors.New("update failed")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, affected, 1)
}
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 {
t.Error(err)
panic(err)
}
if affected != 2 {
err := errors.New("update failed")
t.Error(err)
panic(err)
}
assert.NoError(t, err)
assert.EqualValues(t, affected, 2)
}
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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
}
if true { // 修改全部时，插入空值
@ -225,10 +182,7 @@ func TestNullStructUpdate(t *testing.T) {
}
_, err := testEngine.AllCols().ID(6).Update(item)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
if !has {
t.Error(errors.New("no find id 1"))
panic(err)
}
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)
}
assert.NoError(t, err)
assert.True(t, has)
assert.EqualValues(t, item.Id, 1)
assert.False(t, item.Name.Valid)
assert.False(t, item.Age.Valid)
assert.False(t, item.Height.Valid)
assert.False(t, item.IsMan.Valid)
}
if true {
item := new(NullType)
item.Id = 2
has, err := testEngine.Get(item)
if err != nil {
t.Error(err)
panic(err)
}
if !has {
t.Error(errors.New("no find id 2"))
panic(err)
}
fmt.Println(item)
assert.NoError(t, err)
assert.True(t, has)
}
if true {
item := make([]NullType, 0)
err := testEngine.ID(2).Find(&item)
if err != nil {
t.Error(err)
panic(err)
}
fmt.Println(item)
assert.NoError(t, err)
}
if true {
item := make([]NullType, 0)
err := testEngine.Asc("age").Find(&item)
if err != nil {
t.Error(err)
panic(err)
}
for k, v := range item {
fmt.Println(k, v)
}
assert.NoError(t, err)
}
}
@ -340,10 +264,7 @@ func TestNullStructIterate(t *testing.T) {
fmt.Println(i, nultype)
return nil
})
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
defer rows.Close()
for rows.Next() {
err = rows.Scan(item)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, 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 {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
_, err = testEngine.Where("id > ?", 1).Delete(item)
if err != nil {
t.Error(err)
panic(err)
}
assert.NoError(t, err)
}