Пример #1
0
func TestLogout(t *testing.T) {
	client := apptesting.NewClient()
	creds := url.Values{
		"name":     {"bert_maklin_3"},
		"password": {"my_password"},
	}
	resp, _ := client.PostForm(regServer.URL.String(), creds)
	resp.Body.Close()

	resp, err := client.PostForm(logoutServer.URL.String(), nil)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if ok || cu != nil {
		t.Fatal("Logout должен выполнять успешный выход")
	}

	client.ClearCookie()

	t.Log("Запускаю Logout с пустыми куки...")
	resp, err = client.PostForm(logoutServer.URL.String(), nil)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

}
Пример #2
0
func TestFind(t *testing.T) {
	cr := cred{"find_tester", "qwerty1234567"}
	client := apptesting.NewClient()
	u := prepareTest(t, client, &cr)

	fu, ok := Find(cr.name)
	if !ok {
		t.Fatalf("Find не нашел существующего пользователя: %q", cr.name)
	}
	if fu == nil {
		t.Fatal("Find вернул nil, true")
	}
	if fu.ID != u.ID {
		t.Fatalf("Find нашел не того пользователя. Найден %v, ожидался %v.", fu.ID, u.ID)
	}

	cr2 := cred{"find_inexisting_tester", "qwerty1234567"}
	fu, ok = Find(cr2.name)
	if ok {
		t.Fatalf("Find вернул true при поиске несуществующегося пользователя: %q", cr2.name)
	}
	if fu != nil {
		t.Fatalf("Find вернул %#v, false", fu)
	}
}
Пример #3
0
func TestUser_AutoLogin(t *testing.T) {
	// Подготовить данные для тестовых входов
	cr := cred{"autologin_tester", "qwerty1234567"}
	client := apptesting.NewClient()
	u := prepareTest(t, client, &cr)

	// Запуск AutoLogin на "чистом" клиенте
	client.ClearCookie()
	autoLoginWith(client, u)
	runFromContext(client)
	if !lastOk {
		t.Fatalf("AutoLogin() должно выполнять успешный вход (FromContext() вернуло false)")
	}
	if lastUser == nil {
		t.Fatalf("AutoLogin() должно выполнять успешный вход (FromContext() вернуло nil, true)")
	}
	if lastUser.Name != cr.name {
		t.Errorf("AutoLogin() должно выполнять вход с правильными данными. Ожидалось %q, получено %q.", cr.name, lastUser.Name)
	}

	// Запуск AutoLogin на "занятом" клиенте
	autoLoginWith(client, u)
	runFromContext(client)
	if !lastOk {
		t.Fatalf("AutoLogin() должно выполнять успешный вход с перезаписью (FromContext() вернуло false)")
	}
	if lastUser == nil {
		t.Fatalf("AutoLogin() должно выполнять успешный вход с перезаписью (FromContext() вернуло nil, true)")
	}
	if lastUser.Name != cr.name {
		t.Errorf("AutoLogin() должно выполнять вход с перезаписью с правильными данными. Ожидалось %q, получено %q.", cr.name, lastUser.Name)
	}
}
Пример #4
0
func TestCookieStoring(t *testing.T) {

	sess := FromContext(nil)
	if sess != nil {
		t.Error("FromContext должна возвращать нулевую сессию для нулевого контекста.")
	}

	client := apptesting.NewClient()

	sess1 := retrieveSession(client)
	sess2 := retrieveSession(client)

	client.ClearCookie()
	sess3 := retrieveSession(client)

	// Проверки
	if sess1 == nil || sess3 == nil {
		t.Fatal("Сессия должна быть создана, если не найден ключ сессии в куки.")
	}
	if sess2 == nil {
		t.Fatal("Сессия должна быть получена, если ключ найден в куки.")
	}

	if sess1.ID() != sess2.ID() {
		t.Error("Сессии от одинаковых куки должны быть одинаковыми.")
	}
	if sess1.ID() == sess3.ID() || sess2.ID() == sess3.ID() {
		t.Error("Сессии от разных куки должны быть разными.")
	}

}
Пример #5
0
func TestCountNPages(t *testing.T) {
	client := apptesting.NewClient()
	for i := 0; i < 20; i++ {
		cr := cred{fmt.Sprintf("pages_tester_%v", i), "qwerty12121212"}
		prepareTest(t, client, &cr)
	}

	n := Count()
	if n < 20 {
		t.Errorf("Count вернуло %v, хотя было создано не менее 20 пользователей", n)
	}

	p5n := Pages(5)
	if p5n*5 < n {
		t.Errorf("Pages(5) вернуло %v при %v пользователях", p5n, n)
	}

	arr := FindPage(p5n+1, 5, ByID)
	if len(arr) > 0 {
		t.Errorf("FindPage вернуло непустой слайс для несущ. страницы: %v", arr)
	}

	checkSort := func(sm SortMode, wrongOrd func(a, b *User) bool) {
		p := 1
		if p5n > 1 {
			p = rand.Intn(p5n - 1)
		}
		arr = FindPage(p, 5, sm)
		if len(arr) < 5 {
			t.Errorf("FindPage(%v, 5, %q) вернуло слайс короче 5 (%v), хотя страница гарантировано заполнена", p, sm, len(arr))
		}
		for i := 0; i < len(arr)-1; i++ {
			if wrongOrd(arr[i], arr[i+1]) {
				t.Errorf("FindPage(%v, 5, %q) вернуло неверно отсортированную страницу: %v", p, sm, arr)
				break
			}
		}
	}

	checkSort(ByID, func(a, b *User) bool { return a.ID > b.ID })
	checkSort(ByName, func(a, b *User) bool { return a.Name > b.Name })
	checkSort(ByCreatedAt, func(a, b *User) bool { return a.CreatedAt.Unix() > b.CreatedAt.Unix() })

	checkSort(ByIDDesc, func(a, b *User) bool { return b.ID > a.ID })
	checkSort(ByNameDesc, func(a, b *User) bool { return b.Name > a.Name })
	checkSort(ByCreatedAtDesc, func(a, b *User) bool { return b.CreatedAt.Unix() > a.CreatedAt.Unix() })
}
Пример #6
0
func TestLogin(t *testing.T) {
	client := apptesting.NewClient()
	creds := url.Values{
		"name":     {"bert_maklin_2"},
		"password": {"my_password"},
	}
	resp, _ := client.PostForm(regServer.URL.String(), creds)
	resp.Body.Close()

	client.ClearCookie()

	resp, err := client.PostForm(loginServer.URL.String(), creds)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if !ok || cu == nil {
		t.Fatal("Login должен выполнять успешный вход")
	}
	if cu.Name != creds.Get("name") {
		t.Errorf("Login должен выполнять вход под правильным именем. Ожидалось %v, получено %v.", creds.Get("name"), cu.Name)
	}

	client.ClearCookie()

	creds2 := url.Values{
		"name":     {"bert_maklin_2"},
		"password": {"my_passworddd"},
	}

	resp, err = client.PostForm(loginServer.URL.String(), creds2)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if ok || cu != nil {
		t.Fatal("Login не должен выполнять вход с ошибочными данными")
	}
}
Пример #7
0
func TestUser_Destroy(t *testing.T) {
	// Подготовить данные для тестовых входов
	cr := cred{"destroy_tester", "qwerty1234567"}
	client := apptesting.NewClient()
	u := prepareTest(t, client, &cr)

	// Проверка FromContext после удаления пользователя
	u.Destroy()
	runFromContext(client)
	if lastOk || lastUser != nil {
		t.Error("Destroy() должно делать данные об аутентификации пользователя недоступными")
	}

	// Проверка регистрации после удаления
	cr.pass = "******"
	client.ClearCookie()
	u, err := Register(cr.name, cr.pass)
	if u == nil || err != nil {
		t.Fatal("Перерегистрация удаленного пользователя должна проходить успешно")
	}

	// Проверка входа после удаления
	u.Destroy()
	loginWith(client, &cr)
	if lastOk || lastUser != nil {
		t.Error("Destroy() должно делать вход невозможным")
	}

	// Проверка AutoLogin после удаления
	client.ClearCookie()
	u, err = Register(cr.name, cr.pass)
	if u == nil || err != nil {
		t.Fatal("Перерегистрация удаленного пользователя должна проходить успешно")
	}
	u.Destroy()
	autoLoginWith(client, u)
	if lastOk || lastUser != nil {
		t.Error("Destroy() должно делать AutoLogin невозможным")
	}
}
Пример #8
0
func TestLogout(t *testing.T) {
	// Подготовить данные для тестовых входов
	cr := cred{"logout_tester", "qwerty1234567"}
	client := apptesting.NewClient()
	prepareTest(t, client, &cr)

	// Вызов Logout после успешного входа
	runLogout(client)
	runFromContext(client)
	if lastOk || lastUser != nil {
		t.Error("Logout() должно стирать данные об аутентификации пользователя")
	}

	// Вызов Logout с пустыми куками
	client.ClearCookie()
	t.Log("Logout() должно корректно реагировать на отсутствие аутентификации")
	runLogout(client)
	runFromContext(client)
	if lastOk || lastUser != nil {
		t.Error("Logout() должно корректно реагировать на отсутствие аутентификации")
	}
}
Пример #9
0
func TestDoubleFromContext(t *testing.T) {
	client := apptesting.NewClient()

	resp, err := client.Get(dsServer.URL.String())
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if session.ID() != session2.ID() {
		t.Error("Двойной вызов FromContext на чистом клиенте отдал разные сессии")
	}

	resp, err = client.Get(dsServer.URL.String())
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if session.ID() != session2.ID() {
		t.Error("Двойной вызов FromContext отдал разные сессии")
	}
}
Пример #10
0
func TestDestroy(t *testing.T) {
	client := apptesting.NewClient()
	creds := url.Values{
		"name":     {"bert_maklin_4"},
		"password": {"my_password"},
	}
	resp, _ := client.PostForm(regServer.URL.String(), creds)
	resp.Body.Close()

	resp, err := client.PostForm(desServer.URL.String(), nil)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()
	if ok || cu != nil {
		t.Fatal("Destroy должен стирать данные об аутентификации")
	}

	resp, _ = client.PostForm(loginServer.URL.String(), creds)
	resp.Body.Close()
	if ok || cu != nil {
		t.Fatal("Destroy должен делать последующий вход невозможным")
	}
}
Пример #11
0
func TestRoles(t *testing.T) {
	defCr := cred{"default_role_user", "qwerty1234567"}
	admCr := cred{"admin_user", "qwerty1234567"}
	client := apptesting.NewClient()

	defu := prepareTest(t, client, &defCr)
	if defu.Admin() {
		t.Error("Пользователь с незаданной ролью оказался админом.")
	}

	adm := prepareTest(t, client, &admCr)
	adm.SetRole(AdminRole)
	if !adm.Admin() {
		t.Errorf("Admin вернуло false при вызове на админе: %#v", adm)
	}

	adm1, _ := Find(adm.Name)
	if adm1 == nil {
		t.Fatalf("Find работает некорректно")
	}
	if !adm1.Admin() {
		t.Error("SetRole не сохранил роль в базу")
	}
}
Пример #12
0
func TestRegister(t *testing.T) {
	client := apptesting.NewClient()
	creds := url.Values{
		"name":     {"bert_maklin"},
		"password": {"my_password"},
	}
	resp, err := client.PostForm(regServer.URL.String(), creds)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if !ok || cu == nil {
		t.Fatal("Register должен выполнять успешную регистрацию и вход")
	}
	if cu.Name != creds.Get("name") {
		t.Errorf("Register должен выполнять регистрацию под правильным именем. Ожидалось %v, получено %v.", creds.Get("name"), cu.Name)
	}

	creds1 := url.Values{
		"name":     {"bert_maklin_rereg"},
		"password": {"my_password"},
	}
	resp, err = client.PostForm(regServer.URL.String(), creds1)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if !ok || cu == nil {
		t.Fatal("Register не должен перезаписывать сессию")
	}
	if cu.Name != creds.Get("name") {
		t.Errorf("Register не должен перезаписывать сессию. Ожидалось %v, получено %v.", creds.Get("name"), cu.Name)
	}

	client.ClearCookie()

	resp, _ = client.PostForm(loginServer.URL.String(), creds1)
	resp.Body.Close()

	if ok || cu != nil {
		t.Error("Register не должен выполнять регистрацию при попытке перезаписи сессии")
	}

	client.ClearCookie()

	creds2 := url.Values{
		"name":     {""},
		"password": {""},
	}
	resp, err = client.PostForm(regServer.URL.String(), creds2)
	if err != nil {
		panic(err)
	}
	resp.Body.Close()

	if ok || cu != nil {
		t.Fatal("Register не должен выполнять регистрацию ошибочных данных")
	}
}
Пример #13
0
func TestLoginFromContext(t *testing.T) {

	// Подготовить данные для тестовых входов
	cr := cred{"login_tester", "qwerty1234567"}
	u, err := Register(cr.name, cr.pass)
	if u == nil || err != nil {
		t.Fatal("Register должно работать корректно")
	}

	cr2 := cred{"login_tester_2", "qwerty1234567"}
	u, err = Register(cr2.name, cr2.pass)
	if u == nil || err != nil {
		t.Fatal("Register должно работать корректно")
	}

	cr3 := cred{}

	client := apptesting.NewClient()

	// Login с корректными данными
	loginWith(client, &cr)
	if !lastOk {
		t.Fatalf("Login() должно сообщать об успешной авторизации при получении корректных данных для входа (%#v)", cr)
	}
	if lastUser == nil {
		t.Fatalf("Login() не должно возвращать нулевой указатель в случае успешного входа (%#v)", cr)
	}
	if lastUser.Name != cr.name {
		t.Errorf("Login() должно возвращать правильную структуру. Ожидалось %q, получено %q.", cr.name, lastUser.Name)
	}

	// FromContext после корректного входа
	runFromContext(client)
	if !lastOk {
		t.Fatal("FromContext() должно сообщать об успехе после Login.")
	}
	if lastUser == nil {
		t.Fatalf("FromContext() не должно возвращать нулевой указатель в случае успешного входа (%#v)", cr)
	}
	if lastUser.Name != cr.name {
		t.Errorf("FromContext() должно возвращать правильную структуру. Ожидалось %q, получено %q.", cr.name, lastUser.Name)
	}

	// FromContext при пустых куки
	client.ClearCookie()
	runFromContext(client)
	if lastOk {
		t.Fatal("FromContext() должно сообщать о неуспехе при пустых куки.")
	}
	if lastUser != nil {
		t.Fatalf("FromContext() не должно возвращать структуру пользователя при пустых куки")
	}

	// Login с неверным паролем
	cr3 = cr
	cr3.pass = "******"
	loginWith(client, &cr3)
	if lastOk {
		t.Fatal("Login() должно сообщать о неуспехе при неверном пароле.")
	}
	if lastUser != nil {
		t.Fatalf("Login() не должно возвращать структуру пользователя при неверном пароле")
	}

	// FromContext после неверного пароля
	runFromContext(client)
	if lastOk {
		t.Fatal("FromContext() должно сообщать о неуспехе после вызова Login() с неверным паролем.")
	}
	if lastUser != nil {
		t.Fatalf("FromContext() не должно возвращать структуру пользователя после вызова Login() с неверным паролем")
	}

	// Login с неверным никнеймом
	cr3 = cr
	cr3.name = "undefined_user"
	loginWith(client, &cr3)
	if lastOk {
		t.Fatal("Login() должно сообщать о неуспехе при неверном никнейме.")
	}
	if lastUser != nil {
		t.Fatalf("Login() не должно возвращать структуру пользователя при неверном никнейме")
	}

	// Проверка перезаписи данных Login`ом
	loginWith(client, &cr)
	loginWith(client, &cr2)
	if !lastOk {
		t.Fatalf("Login() должно сообщать об успешной авторизации после записи входа (%#v)", cr)
	}
	if lastUser == nil {
		t.Fatalf("Login() не должно возвращать нулевой указатель после перезаписи входа (%#v)", cr)
	}
	if lastUser.Name != cr2.name {
		t.Errorf("Login() должно возвращать правильную структуру после перезаписи входа. Ожидалось %q, получено %q.", cr2.name, lastUser.Name)
	}
}
Пример #14
0
func TestDataStoring(t *testing.T) {
	client := apptesting.NewClient()

	ints := map[string]int{
		"int1":       12,
		"second int": 34,
	}
	missingInt := "missInt"

	// TODO: Тесты для всех поддерживаемых типов.
	// floats := map[string]float64{
	// 	"float1":       12.04,
	// 	"second float": 3.14,
	// }
	// missingFloat := "missFloat"
	//
	// bytes := map[string][]byte{
	// 	"slice1":       {1, 2, 3, 12},
	// 	"second slice": {},
	// }
	// missingBytes := "missBytes"
	//
	// strings := map[string]string{
	// 	"hello":    "world",
	// 	"username": "******",
	// }
	// missingString := "missString"

	sess := retrieveSession(client)
	if sess == nil {
		t.Fatal("Сессия не должна быть nil.")
	}
	for key, val := range ints {
		assertIntKey(t, "Пустая сессия не должна содержать значений int.", sess, key, 0)
		sess.SetInt(key, val)
	}
	sess.SetInt("", 89)

	sess = retrieveSession(client)
	if sess == nil {
		t.Fatal("Сессия не должна быть nil.")
	}
	for key, val := range ints {
		assertIntKey(t, "Сессия должна сохранять значения int.", sess, key, val)
	}
	assertIntKey(t, "Сессия должна возвращать 0 для незаданных значений.", sess, missingInt, 0)
	assertIntKey(t, "Значения с пустыми ключами не должны сохраняться.", sess, "", 0)

	// Обнуление куки.
	client.ClearCookie()

	sess = retrieveSession(client)
	if sess == nil {
		t.Fatal("Сессия не должна быть nil.")
	}
	sess.SetInt(missingInt, 12)

	sess = retrieveSession(client)
	if sess == nil {
		t.Fatal("Сессия не должна быть nil.")
	}
	for key := range ints {
		assertIntKey(t, "Сессия не должна возвращать значения чужой сессии.", sess, key, 0)
	}
	assertIntKey(t, "Сессия должна сохранять значения int.", sess, missingInt, 12)

}