Run Mock automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
package user_test
import (
"encoding/json"
"fmt"
genid "github.com/srlemon/gen-id"
"github.com/stretchr/testify/assert"
"testing"
"user_center/app"
"user_center/app/Http/Controllers/API/Admin/Context/User/DetailUser"
"user_center/app/Http/Controllers/API/Admin/Context/User/ForbiddenUser"
"user_center/app/Http/Controllers/API/Admin/Context/User/ListUser"
"user_center/app/Http/Controllers/API/Admin/Context/User/StoreUser"
"user_center/app/Http/Controllers/API/Admin/Context/User/UpdateUser"
"user_center/app/Http/Controllers/API/Admin/Responses"
"user_center/app/Model"
"user_center/boot"
"user_center/pkg/db"
"user_center/pkg/test"
)
var httptest *test.Http
func TestMain(m *testing.M) {
boot.SetInTest()
boot.Boot()
httptest = test.New(app.GetEngineRouter())
m.Run()
}
// go test -v test/Feature/Admin/User/user_test.go -test.run TestStore
func TestStore(t *testing.T) {
w := httptest.Post("/api/admin/user/store", StoreUser.Req{
Account: genid.NewGeneratorData().Name,
Phone: genid.NewGeneratorData().PhoneNum,
Email: genid.NewGeneratorData().Email,
Passwd: "123456",
Nickname: genid.NewGeneratorData().GeneratorName(),
Birthday: "2021-11-12 00:00:00",
})
fmt.Println(w.Body)
//t.Logf("resp: %s", w.Body)
//assert.Equal(t, w.Code, 200)
//r := Responses.Response{}
//err = json.Unmarshal(w.Body.Bytes(), &r)
//assert.Nil(t, err)
//assert.Equal(t, 0, r.Code)
}
// go test -v test/Feature/Admin/User/user_test.go -test.run TestDetail
func TestDetail(t *testing.T) {
resp := httptest.Get("/api/admin/user/detail", DetailUser.Req{
ID: 8,
})
fmt.Println(resp.Body)
}
func TestFindPasswordToken(t *testing.T) {
user := &Model.UserAuth{}
err := db.Def().First(&user).Error
assert.Nil(t, err)
assert.NotEmpty(t, user.Phone)
resp := httptest.Get("/api/auth/find/password/token", StoreUser.Req{
Phone: user.Phone,
})
t.Logf("resp: %s", resp.Body)
assert.Equal(t, resp.Code, 200)
r := Responses.Response{}
err = json.Unmarshal(resp.Body.Bytes(), &r)
if body, ok := r.Body.(map[string]interface{}); !ok {
t.Error("ååºå¤ç失败", body)
t.FailNow()
} else {
assert.NotEmpty(t, body["find_password_token"])
}
}
// go test -v test/Feature/Admin/User/user_test.go -test.run TestList
func TestList(t *testing.T) {
resp := httptest.Get("/api/admin/user/list", ListUser.Req{
Page: 1,
Size: 2,
})
fmt.Println(resp.Body)
}
// go test -v test/Feature/Admin/User/user_test.go -test.run TestUpdate
func TestUpdate(t *testing.T) {
w := httptest.Call("PUT", "/api/admin/user/update", UpdateUser.Req{
ID: 3,
Account: genid.NewGeneratorData().Name,
Phone: genid.NewGeneratorData().PhoneNum,
Email: genid.NewGeneratorData().Email,
Nickname: genid.NewGeneratorData().GeneratorName(),
Birthday: "2021-11-13 00:00:00",
})
fmt.Println(w.Body)
}
// go test -v test/Feature/Admin/User/user_test.go -test.run TestForbidden
func TestForbidden(t *testing.T) {
w := httptest.Call("POST", "/api/admin/user/forbidden", ForbiddenUser.Req{
ID: 1,
IsForbidden: 2,
})
fmt.Println(w.Body)
}
//æä½æ°æ®åºçæ¹æ³
package db
import (
"fmt"
"github.com/emicklei/go-restful"
"io"
"net/http"
"strconv"
)
// GET http://localhost:8080/users
//æ¥è¯¢ææç¨æ·
func FindAllUsers(request *restful.Request, response *restful.Response) {
stmt,_:= Mysqldb.Prepare(`select * from user_test`)
defer stmt.Close()
rows,err:=stmt.Query()
if err!=nil {
fmt.Println("æå
¥é误")
}
user:= User{}
Usr :=make([]User,0)
for rows.Next() {
rows.Scan(&user.Id,&user.Name,&user.Age,&user.Gender,&user.Grade,&user.Address)
Usr =append(Usr,user)
}
fmt.Println(Usr)
response.WriteEntity(Usr)
/*
list := []User{}
for _, each := range u.users {
list = append(list, each)
}
response.WriteEntity(list)
*/
}
// GET http://localhost:8080/users/lastid
//æ ¹æ®idæ¥è¯¢ç¨æ·
func FindUser(request *restful.Request, response *restful.Response) {
id := request.PathParameter("user-id")
ID, _:= strconv.Atoi(id)//int Id
user:=User{}
stmt,_:= Mysqldb.Prepare(`select id,name,age,gender,grade,address from user_test where id=?`)
defer stmt.Close()
_,err:=stmt.Exec(ID)
err1:= stmt.QueryRow(ID).Scan(&user.Id, &user.Name, &user.Age, &user.Gender, &user.Grade, &user.Address)
if err!=nil {
fmt.Println("æ§è¡æ¥è¯¢é误")
}else {
fmt.Printf("%d,%s,%d,%s,%d,%s\n",user.Id,user.Name,user.Age,user.Gender,user.Grade,user.Address)
}
if err1!=nil{
fmt.Println("æ¥è¯¢æ«æé误")
io.WriteString(response.ResponseWriter,"ç¨æ·ä¸è½æ¾å°")
}else {
response.WriteEntity(user)
}
}
// PUT http://localhost:8080/users/1
//æ ¹æ®idæ´æ°ç¨æ·
func UpdateUser(request *restful.Request, response *restful.Response) {
id := request.PathParameter("user-id")
ID, _:= strconv.Atoi(id)//int id
stmt,_:=Mysqldb.Prepare(`update user_test set address=? where id=?`)
defer stmt.Close()
_,err:=stmt.Exec("æ ¹æ®idæ´æ°çå°ç¹",ID)
if err!=nil {
fmt.Println("æ´æ°å¤±è´¥")
}else {
fmt.Printf("id=%dæå¨è¡æ´æ°æå\n",ID)
io.WriteString(response.ResponseWriter,"æ´æ°å®æ")
}
/*usr := new(User)
err := request.ReadEntity(&usr)
if err == nil {
u.users[usr.id] =*usr
response.WriteEntity(usr)
} else {
response.WriteError(http.StatusInternalServerError, err)
}*/
}
// POST http://localhost:8080/users/add
//æ«å°¾è¡å建ç¨æ· (u *UserResource)
func CreateUser(request *restful.Request, response *restful.Response) {
//name,age,gender,grade,address
stmt,_:=Mysqldb.Prepare(`insert into user_test (name,age,gender,grade,address) values (?,?,?,?,?)`)
defer stmt.Close()
res,err:=stmt.Exec("å¢å å§å",0,"ç·",0,"æ°å¢å°ç¹")
var LastId,_ =res.LastInsertId()
fmt.Printf("lastid=%dæå¨è¡",LastId)
if err!=nil {
fmt.Println("æå
¥å¤±è´¥")
io.WriteString(response.ResponseWriter,"æ«å°¾è¡æ·»å ç¨æ·å¤±è´¥")
}else {
fmt.Println("æå
¥æå")
io.WriteString(response.ResponseWriter,"æ«å°¾è¡æ·»å ç¨æ·æå")
}
//usr := User{name: request.PathParameter("user-name")}//name:user-name
//usr:=new(User)
//uid:=request.PathParameter("user-id")
/*
usr:=User{id:request.PathParameter("user-id")}
err:=request.ReadEntity(&usr.id)
if err==nil {
u.users[usr.id]=usr
response.WriteEntity(usr)
}else {
response.AddHeader("Content-Type","text/plain")
response.WriteErrorString(http.StatusInternalServerError,err.Error())
}
if err!=nil {
fmt.Println("æå
¥å¤±è´¥")
}
err1 := request.ReadEntity(&usr)
if err1 == nil {
u.users[usr.name] = *usr//User{name:user-name}
response.WriteEntity(usr)
} else {
response.WriteError(http.StatusInternalServerError, err1)
}
*/
}
//POST http://localhost:8080/users/add/{user-id}
//æ ¹æ®idå建ç¨æ·
func CreateUserById(request *restful.Request, response *restful.Response) {
id := request.PathParameter("user-id")
ID, _:= strconv.Atoi(id)//int Id
stmt, _ := Mysqldb.Prepare(`insert into user_test (id,name,age,gender,grade,address) values (?,?,?,?,?,?)`)
defer stmt.Close()
_, err := stmt.Exec(ID,"æ ¹æ®idå¢å çå§å", 10, "ç·", 99, "é»è®¤å°ç¹")
if err != nil {
fmt.Println("æ ¹æ®idæ°å¢è¡å¤±è´¥" )
}
fmt.Printf("æ ¹æ®id=%dæ°å¢æå¨è¡æå\n", ID)
usr := User{Id: ID}
err1 := request.ReadEntity(&usr)
if err1 == nil {
//u.users[usr.Id] = usr
response.WriteHeaderAndEntity(http.StatusCreated, usr)
} else {
response.AddHeader("Content-Type", "text/plain")
response.WriteErrorString(http.StatusInternalServerError, err.Error())
}
/*
usr:=User{id:Id}
err1:=request.ReadEntity(&usr.id)
if err1==nil {
//u.users[usr.id]=usr
response.WriteEntity(usr)
}else {
//response.AddHeader("Content-Type","text/plain")
response.WriteErrorString(http.StatusInternalServerError,err.Error())
}
*/
}
// DELETE http://localhost:8080/users/
//å é¤å°¾è¡ç¨æ·
func RemoveUser(request *restful.Request, response *restful.Response) {
stmt,_:=Mysqldb.Prepare(`delete from user_test order by id desc limit 1`)
defer stmt.Close()
//const Id=19
_,err:=stmt.Exec()
if err!=nil {
fmt.Println("å°¾è¡å é¤å¤±è´¥")
io.WriteString(response.ResponseWriter,"å°¾è¡å é¤å¤±è´¥")
}else{
fmt.Printf("å°¾è¡å é¤æå\n")
io.WriteString(response.ResponseWriter,"å°¾è¡å é¤æå")
}
}
// DELETE http://localhost:8080/users/1
//æ ¹æ®idå é¤ç¨æ·
func RemoveUserById(request *restful.Request, response *restful.Response) {
id := request.PathParameter("user-id")
//delete(u.users, id)//map[id]User
stmt,_:=Mysqldb.Prepare(`delete from user_test where id=?`)
defer stmt.Close()
//const Id=19
_,err:=stmt.Exec(id)
if err!=nil {
fmt.Println("å é¤å¤±è´¥")
io.WriteString(response.ResponseWriter,"å é¤å¤±è´¥")
}else{
fmt.Printf("id=%sæå¨è¡å é¤æå\n",id)
io.WriteString(response.ResponseWriter,"æ ¹æ®idå é¤æå")
}
}
package handlers
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"testing"
"github.com/blackadress/vaula/models"
"github.com/blackadress/vaula/utils"
)
func TestEmptyUsuarioTable(t *testing.T) {
utils.ClearTableUsuario(a.DB)
ensureAuthorizedUserExists()
token := getTestJWT()
token_str := fmt.Sprintf("Bearer %s", token.AccessToken)
req, _ := http.NewRequest("GET", "/users", nil)
req.Header.Set("Authorization", token_str)
response := executeRequest(req, a)
checkResponseCode(t, http.StatusOK, response.Code)
var data []models.User
_ = json.Unmarshal(response.Body.Bytes(), &data)
if len(data) != 1 {
t.Errorf("Expected an array with one element. Got %#v", response.Body.String())
}
}
func TestUnauthorizedToken(t *testing.T) {
utils.ClearTableUsuario(a.DB)
ensureAuthorizedUserExists()
token_str := "Bearer token_invalido"
req, _ := http.NewRequest("GET", "/users", nil)
req.Header.Set("Authorization", token_str)
response := executeRequest(req, a)
checkResponseCode(t, http.StatusUnauthorized, response.Code)
}
func TestGetNonExistentUsuario(t *testing.T) {
utils.ClearTableUsuario(a.DB)
ensureAuthorizedUserExists()
token := getTestJWT()
token_str := fmt.Sprintf("Bearer %s", token.AccessToken)
req, _ := http.NewRequest("GET", "/users/11", nil)
req.Header.Set("Authorization", token_str)
response := executeRequest(req, a)
checkResponseCode(t, http.StatusNotFound, response.Code)
var m map[string]string
json.Unmarshal(response.Body.Bytes(), &m)
if m["error"] != "User not found" {
t.Errorf(
"Expected the 'error' key of the response to be set to 'User not found'. Got '%s'",
m["error"])
}
}
func TestCreateUser(t *testing.T) {
utils.ClearTableUsuario(a.DB)
var jsonStr = []byte(`
{
"username": "user_test",
"password": "1234",
"email": "[email protected]",
"activo": true
}`)
req, _ := http.NewRequest("POST", "/users", bytes.NewBuffer(jsonStr))
req.Header.Set("Content-Type", "application/json")
response := executeRequest(req, a)
checkResponseCode(t, http.StatusCreated, response.Code)
var m map[string]interface{}
json.Unmarshal(response.Body.Bytes(), &m)
if m["username"] != "user_test" {
t.Errorf("Expected user username to be 'user_test'. Got '%v'", m["username"])
}
if m["password"] == "1234" {
t.Errorf("Expected password to have been hashed, it is still '%v'", m["password"])
}
if m["email"] != "[email protected]" {
t.Errorf("Expected user email to be '[email protected]'. Got '%v'", m["email"])
}
if m["activo"] != true {
t.Errorf("Expected user activo to be 'true'. Got '%v'", m["activo"])
}
if m["id"] != 1.0 {
t.Errorf("Expected user ID to be '1'. Got '%v'", m["id"])
}
}
func TestGetUser(t *testing.T) {
utils.ClearTableUsuario(a.DB)
utils.AddUsers(1, a.DB)
ensureAuthorizedUserExists()
token := getTestJWT()
token_str := fmt.Sprintf("Bearer %s", token.AccessToken)
req, _ := http.NewRequest("GET", "/users/1", nil)
req.Header.Set("Authorization", token_str)
response := executeRequest(req, a)
checkResponseCode(t, http.StatusOK, response.Code)
}
func TestUpdateUser(t *testing.T) {
utils.ClearTableUsuario(a.DB)
utils.AddUsers(1, a.DB)
ensureAuthorizedUserExists()
token := getTestJWT()
token_str := fmt.Sprintf("Bearer %s", token.AccessToken)
req, _ := http.NewRequest("GET", "/users/1", nil)
req.Header.Set("Authorization", token_str)
response := executeRequest(req, a)
var originalUser map[string]interface{}
json.Unmarshal(response.Body.Bytes(), &originalUser)
var jsonStr = []byte(`{
"username": "user_test_updated",
"password": "1234_updated",
"email": "[email protected]"}`)
req, _ = http.NewRequest("PUT", "/users/1", bytes.NewBuffer(jsonStr))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", token_str)
response = executeRequest(req, a)
checkResponseCode(t, http.StatusOK, response.Code)
var m map[string]interface{}
json.Unmarshal(response.Body.Bytes(), &m)
if m["id"] != originalUser["id"] {
t.Errorf("Expected the id to remain the same (%v). Got %v", originalUser["id"], m["id"])
}
if m["username"] == originalUser["username"] {
t.Errorf(
"Expected the username to change from '%s' to '%s'. Got '%v'",
originalUser["username"],
m["username"],
originalUser["username"],
)
}
if m["password"] == originalUser["password"] {
t.Errorf(
"Expected the password to change from '%s' to '%s'. Got '%v'",
originalUser["password"],
m["password"],
originalUser["password"],
)
}
if m["email"] == originalUser["email"] {
t.Errorf(
"Expected the email to change from '%s', to '%s'. Got '%v'",
originalUser["email"],
m["email"],
originalUser["email"],
)
}
}
func TestDeleteUser(t *testing.T) {
utils.ClearTableUsuario(a.DB)
utils.AddUsers(1, a.DB)
ensureAuthorizedUserExists()
token := getTestJWT()
token_str := fmt.Sprintf("Bearer %s", token.AccessToken)
req, _ := http.NewRequest("GET", "/users/1", nil)
req.Header.Set("Authorization", token_str)
response := executeRequest(req, a)
checkResponseCode(t, http.StatusOK, response.Code)
req, _ = http.NewRequest("DELETE", "/users/1", nil)
req.Header.Set("Authorization", token_str)
response = executeRequest(req, a)
checkResponseCode(t, http.StatusOK, response.Code)
}
Accelerate Your Automation Test Cycles With LambdaTest
Leverage LambdaTest’s cloud-based platform to execute your automation tests in parallel and trim down your test execution time significantly. Your first 100 automation testing minutes are on us.
