Skip to content

📚 The open-source, offline-first Notion, Obsidian & Confluence alternative. Advanced Markdown, multi-tenant teams, OIDC/SSO, and local S3 backups. Deploy in one command.

Improve tests

Smaug#6739a2bd2f51958a
diff --git a/backend/tests/auth_test.go b/backend/tests/auth_test.go
index 87a1da9b..81dbca90 100644
--- a/backend/tests/auth_test.go
+++ b/backend/tests/auth_test.go
@@ -14,34 +14,13 @@ func LoginAs(t *testing.T, client *http.Client, username, password string) APIRe
}
func TestLogin(t *testing.T) {
+ client := InitClient(t)
t.Run("Correct credentials", func(t *testing.T) {
- client := InitClient(t)
r := LoginAs(t, client, "Smaug", "10082005")
assert.Equal(t, "success", r.Status)
assert.Equal(t, 200, r.StatusCode)
- assert.IsType(t, map[string]any{}, r.Result)
- data, ok := r.Result.(map[string]any)
- if !ok {
- t.Fatalf("The 'result' field is not of type JSON (map[string]any)")
- }
- // Check user data
- assert.Contains(t, data, "id")
- assert.IsType(t, float64(0), data["id"]) // JSON numbers → float64
- assert.Contains(t, data, "username")
- assert.IsType(t, "", data["username"])
- assert.Contains(t, data, "firstname")
- assert.IsType(t, "", data["firstname"])
- assert.Contains(t, data, "lastname")
- assert.IsType(t, "", data["lastname"])
- assert.Contains(t, data, "role")
- assert.IsType(t, float64(0), data["role"])
- assert.Contains(t, data, "avatar") // Can be nil
- assert.Contains(t, data, "email")
- assert.IsType(t, "", data["email"])
- assert.Contains(t, data, "created_timestamp")
- assert.IsType(t, float64(0), data["created_timestamp"])
- assert.Contains(t, data, "updated_timestamp")
- assert.IsType(t, float64(0), data["updated_timestamp"])
+ assert.Equal(t, IsValidUser(t, r), true)
+
// Check if token is present in cookies
url, err := url.Parse(BaseURL)
if err != nil {
diff --git a/backend/tests/helpers.go b/backend/tests/helpers.go
index cdc4f0bd..1798ba8f 100644
--- a/backend/tests/helpers.go
+++ b/backend/tests/helpers.go
@@ -10,6 +10,10 @@ import (
)
const BaseURL = "http://localhost:8080/api"
+const ADMIN_USERNAME = "Smaug"
+const ADMIN_PASSWORD = "10082005"
+const USER_USERNAME = "Baltazar"
+const USER_PASSWORD = "10082005"
type APIResponse struct {
Status string `json:"status"`
@@ -52,12 +56,29 @@ func DoPost(t *testing.T, client *http.Client, path string, body any) APIRespons
return val
}
-func DoGet(t *testing.T, client *http.Client, path string) *http.Response {
+func DoGet(t *testing.T, client *http.Client, path string) APIResponse {
resp, err := client.Get(BaseURL + path)
if err != nil {
t.Fatalf("GET %s failed: %v", path, err)
}
- return resp
+ val := ParseJSONResponse[APIResponse](t, resp)
+ val.StatusCode = resp.StatusCode
+ return val
+}
+
+func DoDelete(t *testing.T, client *http.Client, path string) APIResponse {
+ // Create request
+ req, err := http.NewRequest(http.MethodDelete, BaseURL+path, nil)
+ if err != nil {
+ t.Fatalf("Error creating request: %v", err)
+ }
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("DELETE %s failed: %v", path, err)
+ }
+ val := ParseJSONResponse[APIResponse](t, resp)
+ val.StatusCode = resp.StatusCode
+ return val
}
func ParseJSONResponse[T any](t *testing.T, resp *http.Response) T {
@@ -66,8 +87,14 @@ func ParseJSONResponse[T any](t *testing.T, resp *http.Response) T {
if err != nil {
t.Fatalf("Error during response reading: %v", err)
}
+
var data T
- if err := json.Unmarshal(body, &data); err != nil {
+
+ // Ce bloc permet d’utiliser json.Number dans les maps dynamiques
+ decoder := json.NewDecoder(bytes.NewReader(body))
+ decoder.UseNumber()
+
+ if err := decoder.Decode(&data); err != nil {
t.Fatalf("Error unmarshal JSON: %v\nBody:\n%s", err, body)
}
return data
diff --git a/backend/tests/user_lifecycle_test.go b/backend/tests/user_lifecycle_test.go
new file mode 100644
index 00000000..e85cbe40
--- /dev/null
+++ b/backend/tests/user_lifecycle_test.go
@@ -0,0 +1,160 @@
+package tests
+
+import (
+ "encoding/json"
+ "fmt"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+var partial_user = map[string]any{
+ "firstname": "George",
+ "lastname": "Nolan",
+ "email": "[email protected]",
+}
+
+func TestUserLifeCycle(t *testing.T) {
+ client := InitClient(t)
+
+ // ************************************************************
+ // POST /users/
+ // ************************************************************
+ t.Run("User creation missing password", func(t *testing.T) {
+ partial_user["username"] = "gnolan"
+ response := DoPost(t, client, "/users/", partial_user)
+ assert.Equal(t, "error", response.Status)
+ assert.Equal(t, 400, response.StatusCode)
+ assert.Equal(t, "Password is required", response.Message)
+ })
+ t.Run("User creation missing username", func(t *testing.T) {
+ partial_user["password"] = "password"
+ partial_user["username"] = nil
+ response := DoPost(t, client, "/users/", partial_user)
+ assert.Equal(t, "error", response.Status)
+ assert.Equal(t, 400, response.StatusCode)
+ assert.Equal(t, "Username is required.", response.Message)
+ })
+ t.Run("User creation missing email", func(t *testing.T) {
+ partial_user["username"] = "gnolan"
+ partial_user["password"] = "password"
+ partial_user["email"] = ""
+ response := DoPost(t, client, "/users/", partial_user)
+ assert.Equal(t, "error", response.Status)
+ assert.Equal(t, 400, response.StatusCode)
+ assert.Equal(t, "Email is required.", response.Message)
+ })
+ t.Run("User creation invalid email", func(t *testing.T) {
+ partial_user["username"] = "gnolan"
+ partial_user["password"] = "password"
+ partial_user["email"] = "invalid_email"
+ response := DoPost(t, client, "/users/", partial_user)
+ assert.Equal(t, "error", response.Status)
+ assert.Equal(t, 400, response.StatusCode)
+ assert.Equal(t, "Email must be valid", response.Message)
+ })
+ t.Run("User creation username already exists", func(t *testing.T) {
+ partial_user["username"] = ADMIN_USERNAME
+ partial_user["email"] = "[email protected]"
+ response := DoPost(t, client, "/users/", partial_user)
+ assert.Equal(t, "error", response.Status)
+ assert.Equal(t, 400, response.StatusCode)
+ assert.Equal(t, "Username already exists", response.Message)
+ })
+
+ t.Run("User creation success", func(t *testing.T) {
+ partial_user["username"] = "gnolan"
+ response := DoPost(t, client, "/users/", partial_user)
+ assert.Equal(t, "success", response.Status)
+ assert.Equal(t, 201, response.StatusCode)
+ })
+
+ t.Run("Login as user gnolan", func(t *testing.T) {
+ r := LoginAs(t, client, "gnolan", "password")
+ assert.Equal(t, "success", r.Status)
+ assert.Equal(t, 200, r.StatusCode)
+ assert.Equal(t, IsValidUser(t, r), true)
+ assert.Equal(t, r.Result.(map[string]any)["username"], "gnolan")
+ })
+
+ // ************************************************************
+ // GET /users/XX
+ // ************************************************************
+ var userId int64
+ t.Run("Get @me gnolan", func(t *testing.T) {
+ r := DoGet(t, client, "/users/@me")
+ assert.Equal(t, "success", r.Status)
+ assert.Equal(t, 200, r.StatusCode)
+ assert.Equal(t, IsValidUser(t, r), true)
+ idNum, ok := r.Result.(map[string]any)["id"].(json.Number)
+ if !ok {
+ t.Fatal("ID is not a json.Number")
+ }
+ u, err := idNum.Int64()
+ if err != nil {
+ t.Fatal("Error converting ID to int64:", err)
+ }
+ userId = u
+ assert.Equal(t, r.Result.(map[string]any)["username"], "gnolan")
+ })
+ t.Run("Get user by ID", func(t *testing.T) {
+ r := DoGet(t, client, "/users/"+fmt.Sprintf("%d", userId))
+ assert.Equal(t, "success", r.Status)
+ assert.Equal(t, 200, r.StatusCode)
+ assert.Equal(t, IsValidUser(t, r), true)
+ assert.Equal(t, r.Result.(map[string]any)["username"], "gnolan")
+ })
+ t.Run("Get user by ID with invalid ID", func(t *testing.T) {
+ r := DoGet(t, client, "/users/invalid_id")
+ assert.Equal(t, "error", r.Status)
+ assert.Equal(t, 400, r.StatusCode)
+ assert.Equal(t, "Invalid user ID parameter", r.Message)
+ })
+ t.Run("Get user by ID with non-existing ID", func(t *testing.T) {
+ r := DoGet(t, client, "/users/999999999999999999")
+ assert.Equal(t, "error", r.Status)
+ assert.Equal(t, 400, r.StatusCode)
+ assert.Equal(t, "Unauthorized", r.Message)
+ })
+ // ************************************************************
+ // GET /users/
+ // ************************************************************
+ t.Run("Get all users", func(t *testing.T) {
+ r := DoGet(t, client, "/users/")
+ assert.Equal(t, "error", r.Status)
+ assert.Equal(t, 401, r.StatusCode)
+ assert.Equal(t, "Unauthorized", r.Message)
+ })
+ // ************************************************************
+ // DELETE /users/@me
+ // ************************************************************
+ t.Run("Delete user", func(t *testing.T) {
+ r := DoDelete(t, client, "/users/@me")
+ assert.Equal(t, "success", r.Status)
+ assert.Equal(t, 200, r.StatusCode)
+ })
+ // Check if the user is deleted
+}
+
+func validateUser(user map[string]any) bool {
+ // Check if the user map contains all required fields
+ requiredFields := []string{"id", "username", "firstname", "lastname", "role", "avatar", "email", "created_timestamp", "updated_timestamp"}
+ for _, field := range requiredFields {
+ if _, ok := user[field]; !ok {
+ return false
+ }
+ }
+ return true
+}
+
+func IsValidUser(t *testing.T, r APIResponse) bool {
+ // Check if the data is of type map[string]any
+ assert.IsType(t, map[string]any{}, r.Result)
+ data, ok := r.Result.(map[string]any)
+ if !ok {
+ t.Fatalf("The 'result' field is not of type JSON (map[string]any)")
+ return false
+ }
+ // Check if the data is a valid user
+ return validateUser(data)
+}