Merge branch 'master' of https://github.com/WhiteBatman/xorm
# Conflicts: # engine.go # session_insert_test.go # session_update_test.go
This commit is contained in:
WhiteBatman
commit
1880ee2b96
10
engine.go
10
engine.go
|
|
@ -1545,7 +1545,17 @@ func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}
|
|||
case core.Date:
|
||||
v = t.Format("2006-01-02")
|
||||
case core.DateTime, core.TimeStamp:
|
||||
<<<<<<< HEAD
|
||||
v = t.Format("2006-01-02 15:04:05")
|
||||
=======
|
||||
if engine.dialect.DBType() == "ql" {
|
||||
v = t
|
||||
} else if engine.dialect.DBType() == "sqlite3" {
|
||||
v = t.UTC().Format("2006-01-02 15:04:05")
|
||||
} else {
|
||||
v = t.Format("2006-01-02 15:04:05.999")
|
||||
}
|
||||
>>>>>>> 8c9ffa956bec4149aa6f6961ab1afe93ff93b2eb
|
||||
case core.TimeStampz:
|
||||
if engine.dialect.DBType() == core.MSSQL {
|
||||
v = t.Format("2006-01-02T15:04:05.9999999Z07:00")
|
||||
|
|
|
|||
|
|
@ -5,9 +5,6 @@
|
|||
package xorm
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
|
|
@ -30,635 +27,18 @@ func TestInsertOne(t *testing.T) {
|
|||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestInsertMulti(t *testing.T) {
|
||||
|
||||
assert.NoError(t, prepareEngine())
|
||||
type TestMulti struct {
|
||||
Id int64 `xorm:"int(11) pk"`
|
||||
Name string `xorm:"varchar(255)"`
|
||||
}
|
||||
|
||||
assert.NoError(t, testEngine.Sync2(new(TestMulti)))
|
||||
|
||||
num, err := insertMultiDatas(1,
|
||||
append([]TestMulti{}, TestMulti{1, "test1"}, TestMulti{2, "test2"}, TestMulti{3, "test3"}))
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, 3, num)
|
||||
}
|
||||
|
||||
func insertMultiDatas(step int, datas interface{}) (num int64, err error) {
|
||||
sliceValue := reflect.Indirect(reflect.ValueOf(datas))
|
||||
var iLen int64
|
||||
if sliceValue.Kind() != reflect.Slice {
|
||||
return 0, fmt.Errorf("not silce")
|
||||
}
|
||||
iLen = int64(sliceValue.Len())
|
||||
if iLen == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
session := testEngine.NewSession()
|
||||
defer session.Close()
|
||||
|
||||
if err = callbackLooper(datas, step,
|
||||
func(innerDatas interface{}) error {
|
||||
n, e := session.InsertMulti(innerDatas)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
num += n
|
||||
return nil
|
||||
}); err != nil {
|
||||
return 0, err
|
||||
} else if num != iLen {
|
||||
return 0, fmt.Errorf("num error: %d - %d", num, iLen)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func callbackLooper(datas interface{}, step int, actionFunc func(interface{}) error) (err error) {
|
||||
|
||||
sliceValue := reflect.Indirect(reflect.ValueOf(datas))
|
||||
if sliceValue.Kind() != reflect.Slice {
|
||||
return fmt.Errorf("not slice")
|
||||
}
|
||||
if sliceValue.Len() <= 0 {
|
||||
return
|
||||
}
|
||||
|
||||
tempLen := 0
|
||||
processedLen := sliceValue.Len()
|
||||
for i := 0; i < sliceValue.Len(); i += step {
|
||||
if processedLen > step {
|
||||
tempLen = i + step
|
||||
} else {
|
||||
tempLen = sliceValue.Len()
|
||||
}
|
||||
var tempInterface []interface{}
|
||||
for j := i; j < tempLen; j++ {
|
||||
tempInterface = append(tempInterface, sliceValue.Index(j).Interface())
|
||||
}
|
||||
if err = actionFunc(tempInterface); err != nil {
|
||||
return
|
||||
}
|
||||
processedLen = processedLen - step
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func TestInsertOneIfPkIsPoint(t *testing.T) {
|
||||
func TestInsertOne2(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
type TestPoint struct {
|
||||
Id *int64 `xorm:"autoincr pk notnull 'id'"`
|
||||
Msg *string `xorm:"varchar(255)"`
|
||||
Created *time.Time `xorm:"created"`
|
||||
}
|
||||
|
||||
assert.NoError(t, testEngine.Sync2(new(TestPoint)))
|
||||
msg := "hi"
|
||||
data := TestPoint{Msg: &msg}
|
||||
_, err := testEngine.InsertOne(&data)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestInsertOneIfPkIsPointRename(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
type ID *int64
|
||||
type TestPoint2 struct {
|
||||
Id ID `xorm:"autoincr pk notnull 'id'"`
|
||||
Msg *string `xorm:"varchar(255)"`
|
||||
Created *time.Time `xorm:"created"`
|
||||
}
|
||||
|
||||
assert.NoError(t, testEngine.Sync2(new(TestPoint2)))
|
||||
msg := "hi"
|
||||
data := TestPoint2{Msg: &msg}
|
||||
_, err := testEngine.InsertOne(&data)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestInsert(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
assertSync(t, new(Userinfo))
|
||||
|
||||
user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(),
|
||||
Userdetail{Id: 1}, 1.78, []byte{1, 2, 3}, 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 {
|
||||
err = errors.New("not return id error")
|
||||
t.Error(err)
|
||||
panic(err)
|
||||
}
|
||||
|
||||
user.Uid = 0
|
||||
cnt, err = testEngine.Insert(&user)
|
||||
if err == nil {
|
||||
err = errors.New("insert failed but no return error")
|
||||
t.Error(err)
|
||||
panic(err)
|
||||
}
|
||||
if cnt != 0 {
|
||||
err = errors.New("insert not returned 1")
|
||||
t.Error(err)
|
||||
panic(err)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsertAutoIncr(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
assertSync(t, new(Userinfo))
|
||||
|
||||
// auto increment insert
|
||||
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"))
|
||||
}
|
||||
}
|
||||
|
||||
type DefaultInsert struct {
|
||||
Id int64
|
||||
Status int `xorm:"default -1"`
|
||||
Name string
|
||||
Created time.Time `xorm:"created"`
|
||||
Updated time.Time `xorm:"updated"`
|
||||
}
|
||||
|
||||
func TestInsertDefault(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
di := new(DefaultInsert)
|
||||
err := testEngine.Sync2(di)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
var di2 = DefaultInsert{Name: "test"}
|
||||
_, err = testEngine.Omit(testEngine.ColumnMapper.Obj2Table("Status")).Insert(&di2)
|
||||
if err != nil {
|
||||
t.Error(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)
|
||||
}
|
||||
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 {
|
||||
Id int64
|
||||
Name string
|
||||
Url string `xorm:"text"`
|
||||
CheckTime time.Time `xorm:"not null default '2000-01-01 00:00:00' TIMESTAMP"`
|
||||
}
|
||||
|
||||
func TestInsertDefault2(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
di := new(DefaultInsert2)
|
||||
err := testEngine.Sync2(di)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
var di2 = DefaultInsert2{Name: "test"}
|
||||
_, err = testEngine.Omit(testEngine.ColumnMapper.Obj2Table("CheckTime")).Insert(&di2)
|
||||
if err != nil {
|
||||
t.Error(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)
|
||||
}
|
||||
|
||||
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)
|
||||
}*/
|
||||
}
|
||||
|
||||
type CreatedInsert struct {
|
||||
Id int64
|
||||
Created time.Time `xorm:"created"`
|
||||
}
|
||||
|
||||
type CreatedInsert2 struct {
|
||||
Id int64
|
||||
Created int64 `xorm:"created"`
|
||||
}
|
||||
|
||||
type CreatedInsert3 struct {
|
||||
Id int64
|
||||
Created int `xorm:"created bigint"`
|
||||
}
|
||||
|
||||
type CreatedInsert4 struct {
|
||||
Id int64
|
||||
Created int `xorm:"created"`
|
||||
}
|
||||
|
||||
type CreatedInsert5 struct {
|
||||
Id int64
|
||||
Created time.Time `xorm:"created bigint"`
|
||||
}
|
||||
|
||||
type CreatedInsert6 struct {
|
||||
Id int64
|
||||
Created time.Time `xorm:"created bigint"`
|
||||
}
|
||||
|
||||
func TestInsertCreated(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
di := new(CreatedInsert)
|
||||
err := testEngine.Sync2(di)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ci := &CreatedInsert{}
|
||||
_, err = testEngine.Insert(ci)
|
||||
if err != nil {
|
||||
t.Fatal(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)
|
||||
|
||||
di2 := new(CreatedInsert2)
|
||||
err = testEngine.Sync2(di2)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ci2 := &CreatedInsert2{}
|
||||
_, err = testEngine.Insert(ci2)
|
||||
if err != nil {
|
||||
t.Fatal(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)
|
||||
|
||||
di3 := new(CreatedInsert3)
|
||||
err = testEngine.Sync2(di3)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ci3 := &CreatedInsert3{}
|
||||
_, err = testEngine.Insert(ci3)
|
||||
if err != nil {
|
||||
t.Fatal(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)
|
||||
|
||||
di4 := new(CreatedInsert4)
|
||||
err = testEngine.Sync2(di4)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ci4 := &CreatedInsert4{}
|
||||
_, err = testEngine.Insert(ci4)
|
||||
if err != nil {
|
||||
t.Fatal(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)
|
||||
|
||||
di5 := new(CreatedInsert5)
|
||||
err = testEngine.Sync2(di5)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ci5 := &CreatedInsert5{}
|
||||
_, err = testEngine.Insert(ci5)
|
||||
if err != nil {
|
||||
t.Fatal(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)
|
||||
|
||||
di6 := new(CreatedInsert6)
|
||||
err = testEngine.Sync2(di6)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
oldTime := time.Now().Add(-time.Hour)
|
||||
ci6 := &CreatedInsert6{Created: oldTime}
|
||||
_, err = testEngine.Insert(ci6)
|
||||
if err != nil {
|
||||
t.Fatal(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)
|
||||
}
|
||||
|
||||
type JsonTime time.Time
|
||||
|
||||
func (j JsonTime) format() string {
|
||||
t := time.Time(j)
|
||||
if t.IsZero() {
|
||||
return ""
|
||||
}
|
||||
|
||||
return t.Format("2006-01-02")
|
||||
}
|
||||
|
||||
func (j JsonTime) MarshalText() ([]byte, error) {
|
||||
return []byte(j.format()), nil
|
||||
}
|
||||
|
||||
func (j JsonTime) MarshalJSON() ([]byte, error) {
|
||||
return []byte(`"` + j.format() + `"`), nil
|
||||
}
|
||||
|
||||
func TestDefaultTime3(t *testing.T) {
|
||||
type PrepareTask struct {
|
||||
Id int `xorm:"not null pk autoincr INT(11)" json:"id"`
|
||||
// ...
|
||||
StartTime JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP index" json:"start_time"`
|
||||
EndTime JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP" json:"end_time"`
|
||||
Cuser string `xorm:"not null default '' VARCHAR(64) index" json:"cuser"`
|
||||
Muser string `xorm:"not null default '' VARCHAR(64)" json:"muser"`
|
||||
Ctime JsonTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP created" json:"ctime"`
|
||||
Mtime JsonTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP updated" json:"mtime"`
|
||||
}
|
||||
|
||||
assert.NoError(t, prepareEngine())
|
||||
assertSync(t, new(PrepareTask))
|
||||
|
||||
prepareTask := &PrepareTask{
|
||||
StartTime: JsonTime(time.Now()),
|
||||
Cuser: "userId",
|
||||
Muser: "userId",
|
||||
}
|
||||
cnt, err := testEngine.Omit("end_time").InsertOne(prepareTask)
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, 1, cnt)
|
||||
}
|
||||
|
||||
type MyJsonTime struct {
|
||||
Id int64 `json:"id"`
|
||||
Created JsonTime `xorm:"created" json:"created_at"`
|
||||
}
|
||||
|
||||
func TestCreatedJsonTime(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
di5 := new(MyJsonTime)
|
||||
err := testEngine.Sync2(di5)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ci5 := &MyJsonTime{}
|
||||
_, err = testEngine.Insert(ci5)
|
||||
if err != nil {
|
||||
t.Fatal(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)
|
||||
|
||||
var dis = make([]MyJsonTime, 0)
|
||||
err = testEngine.Find(&dis)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsertMulti2(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
assertSync(t, new(Userinfo))
|
||||
|
||||
users := []Userinfo{
|
||||
{Username: "xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()},
|
||||
{Username: "xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()},
|
||||
{Username: "xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()},
|
||||
{Username: "xlw22", Departname: "dev", Alias: "lunny3", Created: time.Now()},
|
||||
}
|
||||
cnt, err := testEngine.Insert(&users)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
panic(err)
|
||||
}
|
||||
if cnt != int64(len(users)) {
|
||||
err = errors.New("insert not returned 1")
|
||||
t.Error(err)
|
||||
panic(err)
|
||||
return
|
||||
}
|
||||
|
||||
users2 := []*Userinfo{
|
||||
&Userinfo{Username: "1xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()},
|
||||
&Userinfo{Username: "1xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()},
|
||||
&Userinfo{Username: "1xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()},
|
||||
&Userinfo{Username: "1xlw22", Departname: "dev", Alias: "lunny3", Created: time.Now()},
|
||||
}
|
||||
|
||||
cnt, err = testEngine.Insert(&users2)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
panic(err)
|
||||
}
|
||||
|
||||
if cnt != int64(len(users2)) {
|
||||
err = errors.New(fmt.Sprintf("insert not returned %v", len(users2)))
|
||||
t.Error(err)
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsertTwoTable(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
assertSync(t, new(Userinfo), new(Userdetail))
|
||||
|
||||
userdetail := Userdetail{ /*Id: 1, */ Intro: "I'm a very beautiful women.", Profile: "sfsaf"}
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsertCreatedInt64(t *testing.T) {
|
||||
assert.NoError(t, prepareEngine())
|
||||
|
||||
type TestCreatedInt64 struct {
|
||||
type Test2 struct {
|
||||
Id int64 `xorm:"autoincr pk"`
|
||||
Msg string `xorm:"varchar(255)"`
|
||||
Created int64 `xorm:"created"`
|
||||
Created time.Time `xorm:"datetime created"`
|
||||
}
|
||||
|
||||
assert.NoError(t, testEngine.Sync2(new(TestCreatedInt64)))
|
||||
assert.NoError(t, testEngine.Sync2(new(Test2)))
|
||||
|
||||
data := TestCreatedInt64{Msg: "hi"}
|
||||
now := time.Now()
|
||||
cnt, err := testEngine.Insert(&data)
|
||||
data := Test2{Msg: "hi"}
|
||||
_, err := testEngine.InsertOne(data)
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, 1, cnt)
|
||||
assert.True(t, now.Unix() <= data.Created)
|
||||
|
||||
var data2 TestCreatedInt64
|
||||
has, err := testEngine.Get(&data2)
|
||||
assert.NoError(t, err)
|
||||
assert.True(t, has)
|
||||
|
||||
assert.EqualValues(t, data.Created, data2.Created)
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue