Golang 表单验证测试与单元测试实践

type RegisterRequest struct {
    Username string `json:"username"`
    Email    string `json:"email"`
    Password string `json:"password"`
}

func (r *RegisterRequest) Validate() map[string]string {
    errors := make(map[string]string)

    if r.Username == "" {
        errors["username"] = "用户名不能为空"
    } else if len(r.Username) < 3 {
        errors["username"] = "用户名至少3个字符"
    }

    if r.Email == "" {
        errors["email"] = "邮箱不能为空"
    } else if !strings.Contains(r.Email, "@") {
        errors["email"] = "邮箱格式不正确"
    }

    if len(r.Password) < 6 {
        errors["password"] = "密码至少6位"
    }

    return errors
}

func TestRegisterRequest_Validate(t *testing.T) {
    tests := []struct {
        name     string
        request  RegisterRequest
        wantErr  bool
        hasField string
    }{
        {
            name: "valid input",
            request: RegisterRequest{
                Username: "alice",
                Email:    "alice@example.com",
                Password: "secret123",
            },
            wantErr: false,
        },
        {
            name: "short username",
            request: RegisterRequest{
                Username: "ab",
                Email:    "bob@example.com",
                Password: "123456",
            },
            wantErr: true,
            hasField: "username",
        },
        {
            name: "missing email",
            request: RegisterRequest{
                Username: "charlie",
                Email:    "",
                Password: "123456",
            },
            wantErr: true,
            hasField: "email",
        },
        {
            name: "invalid email",
            request: RegisterRequest{
                Username: "dave",
                Email:    "not-email",
                Password: "123456",
            },
            wantErr: true,
            hasField: "email",
        },
        {
            name: "short password",
            request: RegisterRequest{
                Username: "eve",
                Email:    "eve@example.com",
                Password: "123",
            },
            wantErr: true,
            hasField: "password",
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            errs := tt.request.Validate()

            if tt.wantErr && len(errs) == 0 {
                t.Fatalf("expected errors, got none")
            }

            if !tt.wantErr && len(errs) > 0 {
                t.Fatalf("expected no errors, got %v", errs)
            }

            if tt.hasField != "" {
                if _, exists := errs[tt.hasField]; !exists {
                    t.Errorf("expected error on field %s, not found", tt.hasField)
                }
            }
        })
    }
}

func TestRegisterHandler_Validation(t *testing.T) {
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var req RegisterRequest
        json.NewDecoder(r.Body).Decode(&req)

        if errs := req.Validate(); len(errs) > 0 {
            w.WriteHeader(http.StatusBadRequest)
            json.NewEncoder(w).Encode(errs)
            return
        }

        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"message": "ok"}`))
    })

    reqBody := `{"username":"aa","email":"test@example.com","password":"123456"}`
    req := httptest.NewRequest("POST", "/register", strings.NewReader(reqBody))
    req.Header.Set("Content-Type", "application/json")
    w := httptest.NewRecorder()

    handler.ServeHTTP(w, req)

    if w.Code != http.StatusBadRequest {
        t.Errorf("expected status 400, got %d", w.Code)
    }

    var result map[string]string
    json.Unmarshal(w.Body.Bytes(), &result)
    if _, ok := result["username"]; !ok {
        t.Error("expected username error in response")
    }
}