HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add processors tests

This commit is contained in:
Nash Tsai 2013-12-02 14:23:53 +08:00
parent e9a5dddbef
commit fe91775981
1 changed files with 114 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
base_test.go
View File

@ -1709,160 +1709,206 @@ func testPrefixTableName(engine *Engine, t *testing.T) {
type ProcessorsStruct struct { type ProcessorsStruct struct {
Id int64 Id int64
B4InsertFlag bool B4InsertFlag int
AfterInsertedFlag bool AfterInsertedFlag int
B4UpdateFlag bool B4UpdateFlag int
AfterUpdatedFlag bool AfterUpdatedFlag int
B4DeleteFlag bool `xorm:"-"` B4DeleteFlag int `xorm:"-"`
AfterDeletedFlag bool `xorm:"-"` AfterDeletedFlag int `xorm:"-"`
B4InsertViaExt bool B4InsertViaExt int
AfterInsertedViaExt bool AfterInsertedViaExt int
B4UpdateViaExt bool B4UpdateViaExt int
AfterUpdatedViaExt bool AfterUpdatedViaExt int
B4DeleteViaExt bool `xorm:"-"` B4DeleteViaExt int `xorm:"-"`
AfterDeletedViaExt bool `xorm:"-"` AfterDeletedViaExt int `xorm:"-"`
} }
func (p *ProcessorsStruct) BeforeInsert() { func (p *ProcessorsStruct) BeforeInsert() {
p.B4InsertFlag = true p.B4InsertFlag = 1
} }
func (p *ProcessorsStruct) BeforeUpdate() { func (p *ProcessorsStruct) BeforeUpdate() {
p.B4UpdateFlag = true p.B4UpdateFlag = 1
} }
func (p *ProcessorsStruct) BeforeDelete() { func (p *ProcessorsStruct) BeforeDelete() {
p.B4DeleteFlag = true p.B4DeleteFlag = 1
} }
func (p *ProcessorsStruct) AfterInsert() { func (p *ProcessorsStruct) AfterInsert() {
p.AfterInsertedFlag = true p.AfterInsertedFlag = 1
} }
func (p *ProcessorsStruct) AfterUpdate() { func (p *ProcessorsStruct) AfterUpdate() {
p.AfterUpdatedFlag = true p.AfterUpdatedFlag = 1
} }
func (p *ProcessorsStruct) AfterDelete() { func (p *ProcessorsStruct) AfterDelete() {
p.AfterDeletedFlag = true p.AfterDeletedFlag = 1
} }
func testProcessors(engine *Engine, t *testing.T) { func testProcessors(engine *Engine, t *testing.T) {
err := engine.Sync(&ProcessorsStruct{}) tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName)
if err != nil {
t.Error(err)
panic(err)
}
tempEngine.ShowSQL = true
err = tempEngine.DropTables(&ProcessorsStruct{})
if err != nil {
t.Error(err)
panic(err)
}
err = tempEngine.CreateTables(&ProcessorsStruct{})
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} }
p := &ProcessorsStruct{} p := &ProcessorsStruct{}
b4InsertFunc := func(bean interface{}) { b4InsertFunc := func(bean interface{}) {
if v, ok := interface{}(bean).(ProcessorsStruct); ok { if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
v.B4InsertViaExt = true v.B4InsertViaExt = 1
} else { } else {
t.Fail() t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
} }
} }
afterInsertFunc := func(bean interface{}) { afterInsertFunc := func(bean interface{}) {
if v, ok := interface{}(bean).(ProcessorsStruct); ok { if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
v.AfterInsertedViaExt = true v.AfterInsertedViaExt = 1
} else { } else {
t.Fail() t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
} }
} }
_, err = engine.BeforeInsert(b4InsertFunc).AfterInsert(afterInsertFunc).Insert(p) _, err = tempEngine.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} else { } else {
if !p.B4InsertFlag { t.Fail() } if p.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if !p.AfterInsertedFlag { t.Fail() } if p.AfterInsertedFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if !p.B4InsertViaExt { t.Fail() } if p.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if !p.AfterInsertedViaExt { t.Fail() } if p.AfterInsertedViaExt == 0 { t.Error(errors.New("AfterInsertedViaExt not set")) }
} }
p2 := &ProcessorsStruct{} p2 := &ProcessorsStruct{}
_, err = engine.Id(p.Id).Get(p2) _, err = tempEngine.Id(p.Id).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} else { } else {
if !p.B4InsertFlag { t.Fail() } if p2.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if p.AfterInsertedFlag { t.Fail() } if p2.AfterInsertedFlag != 0 { t.Error(errors.New("AfterInsertedFlag is set")) }
if !p.B4InsertViaExt { t.Fail() } if p2.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertViaExt not set")) }
if p.AfterInsertedViaExt { t.Fail() } if p2.AfterInsertedViaExt != 0 { t.Error(errors.New("AfterInsertedViaExt is set")) }
} }
b4UpdateFunc := func(bean interface{}) { b4UpdateFunc := func(bean interface{}) {
if v, ok := interface{}(bean).(ProcessorsStruct); ok { if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
v.B4UpdateViaExt = true v.B4UpdateViaExt = 1
} else { } else {
t.Fail() t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
} }
} }
afterUpdateFunc := func(bean interface{}) { afterUpdateFunc := func(bean interface{}) {
if v, ok := interface{}(bean).(ProcessorsStruct); ok { if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
v.AfterUpdatedViaExt = true v.AfterUpdatedViaExt = 1
} else { } else {
t.Fail() t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
} }
} }
_, err = engine.BeforeUpdate(b4UpdateFunc).AfterUpdate(afterUpdateFunc).Update(p) p = p2 // reset
_, err = tempEngine.Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} else { } else {
if !p.B4UpdateFlag { t.Fail() } if p.B4UpdateFlag == 0 { t.Error(errors.New("B4UpdateFlag not set")) }
if !p.AfterUpdatedFlag { t.Fail() } if p.AfterUpdatedFlag == 0 { t.Error(errors.New("AfterUpdatedFlag not set")) }
if !p.B4UpdateViaExt { t.Fail() } if p.B4UpdateViaExt == 0 { t.Error(errors.New("B4UpdateViaExt not set")) }
if !p.AfterUpdatedViaExt { t.Fail() } if p.AfterUpdatedViaExt == 0 { t.Error(errors.New("AfterUpdatedViaExt not set")) }
} }
_, err = engine.Id(p.Id).Get(p2) p2 = &ProcessorsStruct{}
_, err = tempEngine.Id(p.Id).Get(p2)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} else { } else {
if !p.B4UpdateFlag { t.Fail() } if p2.B4UpdateFlag == 0 { t.Error(errors.New("B4UpdateFlag not set")) }
if p.AfterUpdatedFlag { t.Fail() } if p2.AfterUpdatedFlag != 0 { t.Error(errors.New("AfterUpdatedFlag is set: " + string(p.AfterUpdatedFlag))) }
if !p.B4UpdateViaExt { t.Fail() } if p2.B4UpdateViaExt == 0 { t.Error(errors.New("B4UpdateViaExt not set")) }
if p.AfterUpdatedViaExt { t.Fail() } if p2.AfterUpdatedViaExt != 0 { t.Error(errors.New("AfterUpdatedViaExt is set: " + string(p.AfterUpdatedViaExt))) }
} }
b4DeleteFunc := func(bean interface{}) { b4DeleteFunc := func(bean interface{}) {
if v, ok := interface{}(bean).(ProcessorsStruct); ok { if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
v.B4DeleteViaExt = true v.B4DeleteViaExt = 1
} else { } else {
t.Fail() t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
} }
} }
afterDeleteFunc := func(bean interface{}) { afterDeleteFunc := func(bean interface{}) {
if v, ok := interface{}(bean).(ProcessorsStruct); ok { if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
v.AfterDeletedViaExt = true v.AfterDeletedViaExt = 1
} else { } else {
t.Fail() t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
} }
} }
p = p2 // reset
_, err = engine.BeforeDelete(b4DeleteFunc).AfterDelete(afterDeleteFunc).Delete(p) _, err = tempEngine.Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
panic(err) panic(err)
} else { } else {
if !p.B4DeleteFlag { t.Fail() } if p.B4DeleteFlag == 0 { t.Error(errors.New("B4DeleteFlag not set")) }
if !p.AfterDeletedFlag { t.Fail() } if p.AfterDeletedFlag == 0 { t.Error(errors.New("AfterDeletedFlag not set")) }
if !p.B4DeleteViaExt { t.Fail() } if p.B4DeleteViaExt == 0 { t.Error(errors.New("B4DeleteViaExt not set")) }
if !p.AfterDeletedViaExt { t.Fail() } if p.AfterDeletedViaExt == 0 { t.Error(errors.New("AfterDeletedViaExt not set")) }
} }
// !nashtsai! TODO insert many beans tests // test insert multi
pslice := make([]*ProcessorsStruct, 0);
pslice = append(pslice, &ProcessorsStruct{})
pslice = append(pslice, &ProcessorsStruct{})
cnt, err := tempEngine.Before(b4InsertFunc).After(afterInsertFunc).Insert(&pslice)
if err != nil {
t.Error(err)
panic(err)
} else {
if cnt != 2 { t.Error(errors.New("incorrect insert count")) }
for _, elem := range pslice {
if elem.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if elem.AfterInsertedFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if elem.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if elem.AfterInsertedViaExt == 0 { t.Error(errors.New("AfterInsertedViaExt not set")) }
}
}
for _, elem := range pslice {
p = &ProcessorsStruct{}
_, err = tempEngine.Id(elem.Id).Get(p)
if err != nil {
t.Error(err)
panic(err)
} else {
if p2.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
if p2.AfterInsertedFlag != 0 { t.Error(errors.New("AfterInsertedFlag is set")) }
if p2.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertViaExt not set")) }
if p2.AfterInsertedViaExt != 0 { t.Error(errors.New("AfterInsertedViaExt is set")) }
}
}
} }
func testAll(engine *Engine, t *testing.T) { func testAll(engine *Engine, t *testing.T) {
@ -1959,8 +2005,8 @@ func testAll2(engine *Engine, t *testing.T) {
testTime(engine, t) testTime(engine, t)
fmt.Println("-------------- testPrefixTableName --------------") fmt.Println("-------------- testPrefixTableName --------------")
testPrefixTableName(engine, t) testPrefixTableName(engine, t)
fmt.Println("-------------- transaction --------------")
transaction(engine, t)
fmt.Println("-------------- processors --------------") fmt.Println("-------------- processors --------------")
testProcessors(engine, t) testProcessors(engine, t)
fmt.Println("-------------- transaction --------------")
transaction(engine, t)
} }