Example #1
0
func TestSaveAndFind(t *testing.T) {
	orm := getOrm()
	randomString := toolkit.RandomString(5)
	u := new(user)
	u.Name = randomString
	err := orm.Fork().Save(u)
	if err != nil {
		t.Fatal(err)
	}
	if u.Id < 1 {
		t.Fatal("new id ", u.Id)
	}

	newu := new(user)
	newu.Id = u.Id
	newerr, exists := orm.Fork().Find(newu)
	if newerr != nil {
		t.Fatal(newerr)
	}

	if !exists {
		t.Fatal("save but find ", newu.Id, u.Id)
	}

	if newu.Name != randomString {
		t.Fatal("find diff value")
	}
}
Example #2
0
func TestInsertIgnore(t *testing.T) {
	orm := getOrm()
	ud := new(UserDetail)
	ud.UserId = 1
	ud.Address = toolkit.RandomString(5)
	err := orm.Fork().Save(ud)
	if err != nil {
		t.Fatal("insert ignore error", err)
	}
}
Example #3
0
func TestEx(t *testing.T) {
	cache := getFileCache()
	category := "app/info"
	key := toolkit.RandomString(10)
	defer cache.Del(category, key)

	t1 := test_cache{}
	t1.Id = toolkit.RandInt(0, 10)
	t1.Name = toolkit.RandomString(10)
	err := cache.SetEx(category, key, t1)
	if err != nil {
		t.Fatal(err)
	}
	t2 := test_cache{}
	err, _ = cache.GetEx(category, key, &t2)
	if err != nil {
		t.Fatal(err)
	}

	if t1.Id != t2.Id || t2.Name != t2.Name {
		t.Fatal("error ex")
	}

}
Example #4
0
func TestBaseFileCache(t *testing.T) {
	cache := getFileCache()
	category := "app/install"
	key := toolkit.RandomString(5)
	data := []byte("123")
	cache.Set(category, key, data)
	cacheData, err, exists := cache.Get(category, key)
	if err != nil || !exists {
		t.Fatal("error cache", err, exists)
	}

	if string(cacheData) != string(data) {
		t.Fatal("error data")
	}
}
Example #5
0
func TestSaveTransaction(t *testing.T) {
	orm := getOrm()

	u := new(user)

	//new
	randomString := toolkit.RandomString(5)
	u.Name = randomString
	tx, _ := orm.Transaction()
	err := tx.TSave(u)
	if err != nil {
		t.Fatal(err)
	}
	if u.Id < 1 {
		tx.TRollback()
		t.Fatal("new id ", u.Id)
	} else {
		tx.TCommit()
	}

	//check
	if !checkUserIdAndName(u.Id, randomString) {
		t.Fatal("tsave error")
	} else {
		t.Log("tsave ok")
	}
	fmt.Println("after tnew ", u)

	//update
	randomString = "uuuuu"
	tx, _ = orm.Transaction()
	u.Name = randomString
	err = tx.TSave(u)

	fmt.Println("after tupdate ", u)
	if err != nil {
		t.Fatal("transaction error ", err)
	} else {
		tx.TCommit()
	}
	if !checkUserIdAndName(u.Id, randomString) {
		tx.TRollback()
		t.Fatal("tupdate error")
	} else {
		t.Log("tupdate ok")
	}
}
Example #6
0
func TestDelFileCache(t *testing.T) {
	cache := getFileCache()
	category := "app/info"
	key := toolkit.RandomString(10)
	data := []byte("123")
	cache.Set(category, key, data)
	_, _, exists := cache.Get(category, key)
	if !exists {
		t.Fatal("error get/set")
	}
	cache.Del(category, key)
	_, _, exists = cache.Get(category, key)
	if exists {
		t.Fatal("error del")
	}

}
Example #7
0
func TestTransactionInGoroutine(t *testing.T) {
	orm := getOrm()

	ch := make(chan int)

	tx, _ := orm.Transaction()
	re, _ := tx.TExec("update user_detail set address = ? limit 1", toolkit.RandomString(5))
	fmt.Println("main execed")

	go func(db *Orm, ch chan int, t *testing.T) {
		time.Sleep(2 * time.Second)
		tx, _ := db.Transaction()
		re, _ := tx.TExec("update user set timestamp = now()")
		fmt.Println("goroutine execed")
		ch <- 1
		time.Sleep(2 * time.Second)
		d, _ := re.RowsAffected()
		fmt.Println("goroutine affected:", d)
		if d <= 1 {
			t.Fatal("dirty data in go routine")
		}
		tx.TCommit()
		ch <- 1
	}(orm, ch, t)

	select {
	case <-ch:
		d, _ := re.RowsAffected()
		fmt.Println("main affected:", d)
		if d != 1 {
			t.Fatal("dirty data in main ")
		}
		tx.TCommit()
	}

	select {
	case <-ch:
		t.Log("Complete Transaction in goroutine")
	}
}
Example #8
0
func TestPage(t *testing.T) {
	orm := getOrm()
	u := new(user)

	insert_count := toolkit.RandInt(5, 10)
	t.Log("insert records", insert_count)
	for i := 0; i < insert_count; i++ {
		u := new(user)
		u.Name = toolkit.RandomString(5)
		err := orm.Fork().Save(u)
		FatalError(t, err)
	}

	count, err := orm.Fork().Count(u)
	if count < 1 || err != nil {
		t.Fatal("can not test page because count error :", count, err)
	}

	page := 0
	num := 5
	total_page := count / num
	if count%num != 0 {
		total_page += 1
	}

	for ; page < total_page; page++ {
		page_err, users := orm.Fork().Page(page, num).All(u)
		if page_err != nil {
			t.Fatal("page error:", page, num, page_err)
		}
		for _, tmp := range users {
			t.Log(tmp.(*user))
		}
		t.Log(page, "end")
	}

}