Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

enhancement: standardised error response (#475)

Guilherme Oenning2389dca0a613
diff --git a/app/actions/actions_test.go b/app/actions/actions_test.go
index e47cff853..18c2d973d 100644
--- a/app/actions/actions_test.go
+++ b/app/actions/actions_test.go
@@ -23,31 +23,38 @@ var services = &app.Services{
Notifications: inmemory.NewNotificationStorage(),
}
-func ExpectFailed(result *validate.Result, fields ...string) {
+func ExpectFailed(result *validate.Result, expectedFields ...string) {
Expect(result.Ok).IsFalse()
- Expect(result.Error).IsNil()
- for _, field := range fields {
+ Expect(result.Err).IsNil()
+
+ errFields := make([]string, 0)
+ for _, err := range result.Errors {
+ if err.Field != "" {
+ errFields = append(errFields, err.Field)
+ }
+ }
+
+ for _, field := range expectedFields {
if field == "" {
- Expect(len(result.Messages) > 0).IsTrue()
+ Expect(len(result.Errors) > 0).IsTrue()
} else {
- if len(result.Failures[field]) == 0 {
- Fail("Failures should contain field: %s", field)
+ if !contains(errFields, field) {
+ Fail("Failure should contain field: %s", field)
}
}
}
- for field, _ := range result.Failures {
- if !contains(fields, field) {
- Fail("Failures should not contain field: %s", field)
+ for _, field := range errFields {
+ if !contains(expectedFields, field) {
+ Fail("Failure should not contain field: %s", field)
}
}
}
func ExpectSuccess(result *validate.Result) {
Expect(result.Ok).IsTrue()
- Expect(result.Messages).HasLen(0)
- Expect(result.Failures).HasLen(0)
- Expect(result.Error).IsNil()
+ Expect(result.Errors).HasLen(0)
+ Expect(result.Err).IsNil()
}
func contains(slice []string, item string) bool {
diff --git a/app/actions/idea.go b/app/actions/idea.go
index a17cb96fa..2e19010ab 100644
--- a/app/actions/idea.go
+++ b/app/actions/idea.go
@@ -202,9 +202,7 @@ func (input *DeleteIdea) Validate(user *models.User, services *app.Services) *va
}
if isReferenced {
- return validate.Failed([]string{
- "This idea cannot be deleted because it's being referenced by a duplicated idea.",
- })
+ return validate.Failed("This idea cannot be deleted because it's being referenced by a duplicated idea.")
}
input.Idea = idea
diff --git a/app/actions/invite.go b/app/actions/invite.go
index cd8685b79..9b790268a 100644
--- a/app/actions/invite.go
+++ b/app/actions/invite.go
@@ -56,10 +56,8 @@ func (input *InviteUsers) Validate(user *models.User, services *app.Services) *v
for _, email := range input.Model.Recipients {
if email != "" {
- emailResult := validate.Email(email)
- if !emailResult.Ok {
- result.AddFieldFailure("recipients", emailResult.Messages...)
- }
+ messages := validate.Email(email)
+ result.AddFieldFailure("recipients", messages...)
}
}
diff --git a/app/actions/oauth.go b/app/actions/oauth.go
index e646d49b4..826684fcd 100644
--- a/app/actions/oauth.go
+++ b/app/actions/oauth.go
@@ -43,13 +43,11 @@ func (input *CreateEditOAuthConfig) Validate(user *models.User, services *app.Se
input.Model.Provider = "_" + strings.ToLower(rand.String(10))
}
- uploadResult := validate.ImageUpload(input.Model.Logo, 24, 24, 50)
- if !uploadResult.Ok {
- if uploadResult.Error != nil {
- return validate.Error(uploadResult.Error)
- }
- result.AddFieldFailure("logo", uploadResult.Messages...)
+ messages, err := validate.ImageUpload(input.Model.Logo, 24, 24, 50)
+ if err != nil {
+ return validate.Error(err)
}
+ result.AddFieldFailure("logo", messages...)
if input.Model.Status != models.OAuthConfigEnabled &&
input.Model.Status != models.OAuthConfigDisabled {
@@ -82,20 +80,20 @@ func (input *CreateEditOAuthConfig) Validate(user *models.User, services *app.Se
if input.Model.AuthorizeURL == "" {
result.AddFieldFailure("authorizeUrl", "Authorize URL is required.")
- } else if urlResult := validate.URL(input.Model.AuthorizeURL); !urlResult.Ok {
- result.AddFieldFailure("authorizeUrl", urlResult.Messages...)
+ } else if messages := validate.URL(input.Model.AuthorizeURL); len(messages) > 0 {
+ result.AddFieldFailure("authorizeUrl", messages...)
}
if input.Model.TokenURL == "" {
result.AddFieldFailure("tokenUrl", "Token URL is required.")
- } else if urlResult := validate.URL(input.Model.TokenURL); !urlResult.Ok {
- result.AddFieldFailure("tokenUrl", urlResult.Messages...)
+ } else if messages := validate.URL(input.Model.TokenURL); len(messages) > 0 {
+ result.AddFieldFailure("tokenUrl", messages...)
}
if input.Model.ProfileURL == "" {
result.AddFieldFailure("profileUrl", "Profile URL is required.")
- } else if urlResult := validate.URL(input.Model.ProfileURL); !urlResult.Ok {
- result.AddFieldFailure("profileUrl", urlResult.Messages...)
+ } else if messages := validate.URL(input.Model.ProfileURL); len(messages) > 0 {
+ result.AddFieldFailure("profileUrl", messages...)
}
if input.Model.JSONUserIDPath == "" {
diff --git a/app/actions/oauth_test.go b/app/actions/oauth_test.go
index 686a0352d..10a4ddd4b 100644
--- a/app/actions/oauth_test.go
+++ b/app/actions/oauth_test.go
@@ -159,6 +159,6 @@ func TestCreateEditOAuthConfig_EditNonExisting(t *testing.T) {
Model: input,
}
result := action.Validate(nil, services)
- Expect(result.Error).Equals(app.ErrNotFound)
+ Expect(result.Err).Equals(app.ErrNotFound)
Expect(result.Ok).IsFalse()
}
diff --git a/app/actions/signin.go b/app/actions/signin.go
index fbbcf8c90..6f1b9df1a 100644
--- a/app/actions/signin.go
+++ b/app/actions/signin.go
@@ -36,10 +36,8 @@ func (input *SignInByEmail) Validate(user *models.User, services *app.Services)
result.AddFieldFailure("email", "Email must have less than 200 characters.")
}
- emailResult := validate.Email(input.Model.Email)
- if !emailResult.Ok {
- result.AddFieldFailure("email", emailResult.Messages...)
- }
+ messages := validate.Email(input.Model.Email)
+ result.AddFieldFailure("email", messages...)
return result
}
diff --git a/app/actions/tag_test.go b/app/actions/tag_test.go
new file mode 100644
index 000000000..1a25cefbb
--- /dev/null
+++ b/app/actions/tag_test.go
@@ -0,0 +1,58 @@
+package actions_test
+
+import (
+ "testing"
+
+ "github.com/getfider/fider/app/actions"
+ "github.com/getfider/fider/app/models"
+ . "github.com/getfider/fider/app/pkg/assert"
+ "github.com/getfider/fider/app/pkg/rand"
+)
+
+func TestCreateEditTag_InvalidName(t *testing.T) {
+ RegisterT(t)
+
+ services.Tags.Add("Feature Request", "000000", true)
+
+ for _, name := range []string{
+ "",
+ "Feature Request",
+ rand.String(31),
+ } {
+ action := &actions.CreateEditTag{Model: &models.CreateEditTag{Name: name, Color: "FFFFFF"}}
+ result := action.Validate(nil, services)
+ ExpectFailed(result, "name")
+ }
+}
+
+func TestCreateEditTag_InvalidColor(t *testing.T) {
+ RegisterT(t)
+
+ for _, color := range []string{
+ "",
+ "ABC",
+ "PPPOOO",
+ "FFF",
+ "000000X",
+ } {
+ action := &actions.CreateEditTag{Model: &models.CreateEditTag{Name: "Bug", Color: color}}
+ result := action.Validate(nil, services)
+ ExpectFailed(result, "color")
+ }
+}
+
+func TestCreateEditTag_ValidInput(t *testing.T) {
+ RegisterT(t)
+
+ tag, _ := services.Tags.Add("To Discuss", "000000", true)
+
+ action := &actions.CreateEditTag{Model: &models.CreateEditTag{Name: "Bug", Color: "FF0000"}}
+ result := action.Validate(nil, services)
+ ExpectSuccess(result)
+ Expect(action.Tag).IsNil()
+
+ action = &actions.CreateEditTag{Model: &models.CreateEditTag{Name: "New Name", Slug: "to-discuss", Color: "FF0000"}}
+ result = action.Validate(nil, services)
+ ExpectSuccess(result)
+ Expect(action.Tag).Equals(tag)
+}
diff --git a/app/actions/tenant.go b/app/actions/tenant.go
index f2e6d3535..17bbe1ebb 100644
--- a/app/actions/tenant.go
+++ b/app/actions/tenant.go
@@ -42,12 +42,8 @@ func (input *CreateTenant) Validate(user *models.User, services *app.Services) *
if input.Model.Email == "" {
result.AddFieldFailure("email", "Email is required.")
} else {
- emailResult := validate.Email(input.Model.Email)
- if !emailResult.Ok && emailResult.Error != nil {
- return emailResult
- } else if !emailResult.Ok {
- result.AddFieldFailure("email", emailResult.Messages...)
- }
+ messages := validate.Email(input.Model.Email)
+ result.AddFieldFailure("email", messages...)
}
if input.Model.Name == "" {
@@ -66,13 +62,13 @@ func (input *CreateTenant) Validate(user *models.User, services *app.Services) *
result.AddFieldFailure("tenantName", "Name is required.")
}
- subdomainResult := validate.Subdomain(services.Tenants, input.Model.Subdomain)
- if !subdomainResult.Ok && subdomainResult.Error != nil {
- return subdomainResult
- } else if !subdomainResult.Ok {
- result.AddFieldFailure("subdomain", subdomainResult.Messages...)
+ messages, err := validate.Subdomain(services.Tenants, input.Model.Subdomain)
+ if err != nil {
+ return validate.Error(err)
}
+ result.AddFieldFailure("subdomain", messages...)
+
if env.HasLegal() && !input.Model.LegalAgreement {
result.AddFieldFailure("legalAgreement", "You must agree before proceeding.")
}
@@ -100,13 +96,11 @@ func (input *UpdateTenantSettings) IsAuthorized(user *models.User, services *app
func (input *UpdateTenantSettings) Validate(user *models.User, services *app.Services) *validate.Result {
result := validate.Success()
- uploadResult := validate.ImageUpload(input.Model.Logo, 200, 200, 100)
- if !uploadResult.Ok {
- if uploadResult.Error != nil {
- return validate.Error(uploadResult.Error)
- }
- result.AddFieldFailure("logo", uploadResult.Messages...)
+ messages, err := validate.ImageUpload(input.Model.Logo, 200, 200, 100)
+ if err != nil {
+ return validate.Error(err)
}
+ result.AddFieldFailure("logo", messages...)
if input.Model.Title == "" {
result.AddFieldFailure("title", "Title is required.")
@@ -121,9 +115,8 @@ func (input *UpdateTenantSettings) Validate(user *models.User, services *app.Ser
}
if input.Model.CNAME != "" {
- if cnameResult := validate.CNAME(services.Tenants, input.Model.CNAME); !cnameResult.Ok {
- result.AddFieldFailure("cname", cnameResult.Messages...)
- }
+ messages := validate.CNAME(services.Tenants, input.Model.CNAME)
+ result.AddFieldFailure("cname", messages...)
}
return result
diff --git a/app/actions/user.go b/app/actions/user.go
index d77e177b0..8f3b8bb1f 100644
--- a/app/actions/user.go
+++ b/app/actions/user.go
@@ -81,9 +81,9 @@ func (input *ChangeUserEmail) Validate(user *models.User, services *app.Services
return result
}
- emailResult := validate.Email(input.Model.Email)
- if !emailResult.Ok {
- result.AddFieldFailure("email", emailResult.Messages...)
+ messages := validate.Email(input.Model.Email)
+ if len(messages) > 0 {
+ result.AddFieldFailure("email", messages...)
return result
}
diff --git a/app/handlers/signup.go b/app/handlers/signup.go
index fc378d7e6..4eda9124b 100644
--- a/app/handlers/signup.go
+++ b/app/handlers/signup.go
@@ -23,9 +23,10 @@ func CheckAvailability() web.HandlerFunc {
return func(c web.Context) error {
subdomain := strings.ToLower(c.Param("subdomain"))
- if result := validate.Subdomain(c.Services().Tenants, subdomain); !result.Ok {
+ messages, _ := validate.Subdomain(c.Services().Tenants, subdomain)
+ if len(messages) > 0 {
return c.Ok(web.Map{
- "message": strings.Join(result.Messages, ","),
+ "message": strings.Join(messages, ","),
})
}
diff --git a/app/handlers/tag_test.go b/app/handlers/tag_test.go
index 1b7ec0286..cc0fccf28 100644
--- a/app/handlers/tag_test.go
+++ b/app/handlers/tag_test.go
@@ -36,30 +36,23 @@ func TestCreateTagHandler_ValidRequests(t *testing.T) {
func TestCreateTagHandler_InvalidRequests(t *testing.T) {
RegisterT(t)
- var testCases = []struct {
- input string
- failures []string
- }{
- {`{ }`, []string{"failures.name", "failures.color"}},
- {`{ "name": "" }`, []string{"failures.name", "failures.color"}},
- {`{ "name": "Bug" }`, []string{"failures.color"}},
- {`{ "name": "Bug", "color": "ABC" }`, []string{"failures.color"}},
- {`{ "name": "Bug", "color": "00000X" }`, []string{"failures.color"}},
- {`{ "name": "123456789012345678901234567890A", "color": "000000" }`, []string{"failures.name"}},
+ var testCases = []string{
+ `{ }`,
+ `{ "name": "" }`,
+ `{ "name": "Bug" }`,
+ `{ "name": "Bug", "color": "ABC" }`,
+ `{ "name": "Bug", "color": "00000X" }`,
+ `{ "name": "123456789012345678901234567890A", "color": "000000" }`,
}
for _, testCase := range testCases {
server, _ := mock.NewServer()
- status, query := server.
+ status, _ := server.
AsUser(mock.JonSnow).
- ExecutePostAsJSON(handlers.CreateEditTag(), testCase.input)
+ ExecutePostAsJSON(handlers.CreateEditTag(), testCase)
Expect(status).Equals(http.StatusBadRequest)
- for _, failure := range testCase.failures {
- Expect(query.Contains(failure)).IsTrue()
- }
}
-
}
func TestCreateTagHandler_AlreadyInUse(t *testing.T) {
@@ -68,7 +61,7 @@ func TestCreateTagHandler_AlreadyInUse(t *testing.T) {
server, services := mock.NewServer()
services.Tags.Add("Bug", "0000FF", true)
- status, query := server.
+ status, _ := server.
AsUser(mock.JonSnow).
ExecutePostAsJSON(
handlers.CreateEditTag(),
@@ -76,7 +69,6 @@ func TestCreateTagHandler_AlreadyInUse(t *testing.T) {
)
Expect(status).Equals(http.StatusBadRequest)
- Expect(query.Contains("failures.name")).IsTrue()
}
func TestCreateTagHandler_Collaborator(t *testing.T) {
diff --git a/app/pkg/validate/general.go b/app/pkg/validate/general.go
index 413fb68d0..4a8328a2d 100644
--- a/app/pkg/validate/general.go
+++ b/app/pkg/validate/general.go
@@ -14,63 +14,59 @@ var emailRegex = regexp.MustCompile("^(((([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?
var hostnameRegex = regexp.MustCompile(`^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$`)
//Email validates given email address
-func Email(email string) *Result {
+func Email(email string) []string {
email = strings.ToLower(email)
if len(email) > 200 {
- return Failed([]string{"Email address must have less than 200 characters."})
+ return []string{"Email address must have less than 200 characters."}
}
if !emailRegex.MatchString(email) {
- return Failed([]string{fmt.Sprintf("'%s' is not a valid email address.", email)})
+ return []string{fmt.Sprintf("'%s' is not a valid email address.", email)}
}
- return Success()
+ return []string{}
}
//URL validates given URL
-func URL(rawurl string) *Result {
+func URL(rawurl string) []string {
rawurl = strings.ToLower(rawurl)
if len(rawurl) > 300 {
- return Failed([]string{"URL address must have less than 300 characters."})
+ return []string{"URL address must have less than 300 characters."}
}
_, err := url.ParseRequestURI(rawurl)
if err != nil {
- return Failed([]string{fmt.Sprintf("'%s' is not a valid URL address.", rawurl)})
+ return []string{fmt.Sprintf("'%s' is not a valid URL address.", rawurl)}
}
- return Success()
+ return []string{}
}
//CNAME validates given cname
-func CNAME(tenants storage.Tenant, cname string) *Result {
+func CNAME(tenants storage.Tenant, cname string) []string {
cname = strings.ToLower(cname)
if !env.IsSingleHostMode() {
domain := env.MultiTenantDomain()
if strings.HasSuffix(cname, domain) || cname == domain[1:] {
- return Failed([]string{fmt.Sprintf("'%s' is not a valid custom domain.", cname)})
+ return []string{fmt.Sprintf("'%s' is not a valid custom domain.", cname)}
}
}
if len(cname) > 100 {
- return Failed([]string{"Custom domain name must have less than 100 characters."})
+ return []string{"Custom domain name must have less than 100 characters."}
}
if !hostnameRegex.MatchString(cname) || strings.Index(cname, ".") == -1 {
- return Failed([]string{fmt.Sprintf("'%s' is not a valid custom domain.", cname)})
- }
-
- available, err := tenants.IsCNAMEAvailable(cname)
- if err != nil {
- return Error(err)
+ return []string{fmt.Sprintf("'%s' is not a valid custom domain.", cname)}
}
+ available, _ := tenants.IsCNAMEAvailable(cname)
if !available {
- return Failed([]string{"This custom domain is already in use by someone else."})
+ return []string{"This custom domain is already in use by someone else."}
}
- return Success()
+ return []string{}
}
diff --git a/app/pkg/validate/general_test.go b/app/pkg/validate/general_test.go
index bee5aa1c7..1e0e2a1a1 100644
--- a/app/pkg/validate/general_test.go
+++ b/app/pkg/validate/general_test.go
@@ -25,10 +25,8 @@ func TestInvalidEmail(t *testing.T) {
rand.String(200) + "@gmail.com",
} {
- result := validate.Email(email)
- Expect(result.Ok).IsFalse()
- Expect(len(result.Messages) > 0).IsTrue()
- Expect(result.Error).IsNil()
+ messages := validate.Email(email)
+ Expect(len(messages) > 0).IsTrue()
}
}
@@ -40,10 +38,8 @@ func TestValidEmail(t *testing.T) {
} {
- result := validate.Email(email)
- Expect(result.Ok).IsTrue()
- Expect(result.Messages).HasLen(0)
- Expect(result.Error).IsNil()
+ messages := validate.Email(email)
+ Expect(messages).HasLen(0)
}
}
@@ -57,10 +53,8 @@ func TestInvalidURL(t *testing.T) {
rand.String(301),
"my@company",
} {
- result := validate.URL(rawurl)
- Expect(result.Ok).IsFalse()
- Expect(len(result.Messages) > 0).IsTrue()
- Expect(result.Error).IsNil()
+ messages := validate.URL(rawurl)
+ Expect(len(messages) > 0).IsTrue()
}
}
@@ -72,10 +66,8 @@ func TestValidURL(t *testing.T) {
"https://example.org/oauth",
"https://example.org/oauth?test=abc",
} {
- result := validate.URL(rawurl)
- Expect(result.Ok).IsTrue()
- Expect(result.Messages).HasLen(0)
- Expect(result.Error).IsNil()
+ messages := validate.URL(rawurl)
+ Expect(messages).HasLen(0)
}
}
@@ -92,10 +84,8 @@ func TestInvalidCNAME(t *testing.T) {
"test.fider.io",
"@google.com",
} {
- result := validate.CNAME(inmemory.NewTenantStorage(), cname)
- Expect(result.Ok).IsFalse()
- Expect(len(result.Messages) > 0).IsTrue()
- Expect(result.Error).IsNil()
+ messages := validate.CNAME(inmemory.NewTenantStorage(), cname)
+ Expect(len(messages) > 0).IsTrue()
}
}
@@ -109,10 +99,8 @@ func TestValidHostname(t *testing.T) {
"got.com",
"hi.m",
} {
- result := validate.CNAME(inmemory.NewTenantStorage(), cname)
- Expect(result.Ok).IsTrue()
- Expect(result.Messages).HasLen(0)
- Expect(result.Error).IsNil()
+ messages := validate.CNAME(inmemory.NewTenantStorage(), cname)
+ Expect(messages).HasLen(0)
}
}
@@ -125,24 +113,22 @@ func TestValidCNAME_Availability(t *testing.T) {
tenant.CNAME = "fider.yourcompany.com"
tenant, _ = tenants.Add("New York", "newyork", models.TenantActive)
tenant.CNAME = "feedback.newyork.com"
+
for _, cname := range []string{
"footbook.com",
"fider.yourcompany.com",
"feedback.newyork.com",
} {
- result := validate.CNAME(tenants, cname)
- Expect(result.Ok).IsFalse()
- Expect(len(result.Messages) > 0).IsTrue()
- Expect(result.Error).IsNil()
+ messages := validate.CNAME(tenants, cname)
+ Expect(len(messages) > 0).IsTrue()
}
+
for _, cname := range []string{
"fider.footbook.com",
"yourcompany.com",
"anything.com",
} {
- result := validate.CNAME(tenants, cname)
- Expect(result.Ok).IsTrue()
- Expect(result.Messages).HasLen(0)
- Expect(result.Error).IsNil()
+ messages := validate.CNAME(tenants, cname)
+ Expect(messages).HasLen(0)
}
}
diff --git a/app/pkg/validate/subdomain.go b/app/pkg/validate/subdomain.go
index e50ea49eb..398c48d11 100644
--- a/app/pkg/validate/subdomain.go
+++ b/app/pkg/validate/subdomain.go
@@ -12,19 +12,19 @@ import (
var domainRegex = regexp.MustCompile("^[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]$")
//Subdomain validates given subdomain
-func Subdomain(tenants storage.Tenant, subdomain string) *Result {
+func Subdomain(tenants storage.Tenant, subdomain string) ([]string, error) {
subdomain = strings.ToLower(subdomain)
if len(subdomain) <= 2 {
- return Failed([]string{"Subdomain must have more than 2 characters."})
+ return []string{"Subdomain must have more than 2 characters."}, nil
}
if len(subdomain) > 40 {
- return Failed([]string{"Subdomain must have less than 40 characters."})
+ return []string{"Subdomain must have less than 40 characters."}, nil
}
if !domainRegex.MatchString(subdomain) {
- return Failed([]string{"Subdomain contains invalid characters."})
+ return []string{"Subdomain contains invalid characters."}, nil
}
switch subdomain {
@@ -32,17 +32,17 @@ func Subdomain(tenants storage.Tenant, subdomain string) *Result {
"signup", "fider", "login", "customers", "admin", "setup", "about",
"wecanhearyou", "dev", "mail", "billing", "www", "web", "translate",
"help", "support", "status", "staging", "cdn", "assets":
- return Failed([]string{fmt.Sprintf("%s is a reserved subdomain.", subdomain)})
+ return []string{fmt.Sprintf("%s is a reserved subdomain.", subdomain)}, nil
}
available, err := tenants.IsSubdomainAvailable(subdomain)
if err != nil {
- return Error(err)
+ return nil, err
}
if !available {
- return Failed([]string{"This subdomain is not available anymore."})
+ return []string{"This subdomain is not available anymore."}, nil
}
- return Success()
+ return []string{}, nil
}
diff --git a/app/pkg/validate/subdomain_test.go b/app/pkg/validate/subdomain_test.go
index 79d46ef17..4d2bfdc45 100644
--- a/app/pkg/validate/subdomain_test.go
+++ b/app/pkg/validate/subdomain_test.go
@@ -23,10 +23,9 @@ func TestInvalidSubdomains(t *testing.T) {
"my+company",
"1234567890123456789012345678901234567890ABC",
} {
- result := validate.Subdomain(nil, subdomain)
- Expect(result.Ok).IsFalse()
- Expect(len(result.Messages) > 0).IsTrue()
- Expect(result.Error).IsNil()
+ messages, err := validate.Subdomain(nil, subdomain)
+ Expect(len(messages) > 0).IsTrue()
+ Expect(err).IsNil()
}
}
@@ -44,19 +43,17 @@ func TestValidSubdomains_Availability(t *testing.T) {
"newyork",
"NewYork",
} {
- result := validate.Subdomain(tenants, subdomain)
- Expect(result.Ok).IsFalse()
- Expect(len(result.Messages) > 0).IsTrue()
- Expect(result.Error).IsNil()
+ messages, err := validate.Subdomain(tenants, subdomain)
+ Expect(len(messages) > 0).IsTrue()
+ Expect(err).IsNil()
}
for _, subdomain := range []string{
"my-company",
"123-company",
} {
- result := validate.Subdomain(tenants, subdomain)
- Expect(result.Ok).IsTrue()
- Expect(result.Messages).HasLen(0)
- Expect(result.Error).IsNil()
+ messages, err := validate.Subdomain(tenants, subdomain)
+ Expect(messages).HasLen(0)
+ Expect(err).IsNil()
}
}
diff --git a/app/pkg/validate/upload.go b/app/pkg/validate/upload.go
index 9fe3a3705..aae697dfb 100644
--- a/app/pkg/validate/upload.go
+++ b/app/pkg/validate/upload.go
@@ -8,7 +8,7 @@ import (
)
//ImageUpload validates given image upload
-func ImageUpload(upload *models.ImageUpload, minWidth, minHeight, maxKilobytes int) *Result {
+func ImageUpload(upload *models.ImageUpload, minWidth, minHeight, maxKilobytes int) ([]string, error) {
messages := []string{}
if upload != nil && upload.Upload != nil && len(upload.Upload.Content) > 0 {
@@ -17,7 +17,7 @@ func ImageUpload(upload *models.ImageUpload, minWidth, minHeight, maxKilobytes i
if err == img.ErrNotSupported {
messages = append(messages, "This file format not supported.")
} else {
- return Error(err)
+ return nil, err
}
} else {
if logo.Width < minWidth || logo.Height < minHeight {
@@ -34,8 +34,5 @@ func ImageUpload(upload *models.ImageUpload, minWidth, minHeight, maxKilobytes i
}
}
- if len(messages) > 0 {
- return Failed(messages)
- }
- return Success()
+ return messages, nil
}
diff --git a/app/pkg/validate/upload_test.go b/app/pkg/validate/upload_test.go
index 536474aaf..44e20df4d 100644
--- a/app/pkg/validate/upload_test.go
+++ b/app/pkg/validate/upload_test.go
@@ -15,15 +15,15 @@ func TestValidateImageUpload(t *testing.T) {
var testCases = []struct {
fileName string
- valid bool
+ count int
}{
- {"/app/pkg/img/testdata/logo1.png", true},
- {"/app/pkg/img/testdata/logo2.jpg", false},
- {"/app/pkg/img/testdata/logo3.gif", false},
- {"/app/pkg/img/testdata/logo4.png", false},
- {"/app/pkg/img/testdata/logo5.png", true},
- {"/README.md", false},
- {"/favicon.ico", false},
+ {"/app/pkg/img/testdata/logo1.png", 0},
+ {"/app/pkg/img/testdata/logo2.jpg", 2},
+ {"/app/pkg/img/testdata/logo3.gif", 1},
+ {"/app/pkg/img/testdata/logo4.png", 1},
+ {"/app/pkg/img/testdata/logo5.png", 0},
+ {"/README.md", 1},
+ {"/favicon.ico", 1},
}
for _, testCase := range testCases {
@@ -34,17 +34,20 @@ func TestValidateImageUpload(t *testing.T) {
Content: img,
},
}
- result := validate.ImageUpload(upload, 200, 200, 100)
- Expect(result.Ok).Equals(testCase.valid)
+ messages, err := validate.ImageUpload(upload, 200, 200, 100)
+ Expect(messages).HasLen(testCase.count)
+ Expect(err).IsNil()
}
}
func TestValidateImageUpload_Nil(t *testing.T) {
RegisterT(t)
- result := validate.ImageUpload(nil, 200, 200, 50)
- Expect(result.Ok).IsTrue()
+ messages, err := validate.ImageUpload(nil, 200, 200, 50)
+ Expect(messages).HasLen(0)
+ Expect(err).IsNil()
- result = validate.ImageUpload(&models.ImageUpload{}, 200, 200, 50)
- Expect(result.Ok).IsTrue()
+ messages, err = validate.ImageUpload(&models.ImageUpload{}, 200, 200, 50)
+ Expect(messages).HasLen(0)
+ Expect(err).IsNil()
}
diff --git a/app/pkg/validate/validation.go b/app/pkg/validate/validation.go
index 096d0b097..9e1867d0e 100644
--- a/app/pkg/validate/validation.go
+++ b/app/pkg/validate/validation.go
@@ -11,29 +11,33 @@ type Validatable interface {
IsAuthorized(user *models.User, services *app.Services) bool
}
+// ErrorItem holds a reference to something that went wrong
+type ErrorItem struct {
+ Field string `json:"field,omitempty"`
+ Message string `json:"message"`
+}
+
// Result is returned after each validation
type Result struct {
Ok bool
Authorized bool
- Error error
- Messages []string
- Failures map[string][]string
+ Err error
+ Errors []ErrorItem
}
//AddFieldFailure add failure message to specific field
func (r *Result) AddFieldFailure(field string, messages ...string) {
- if r.Failures == nil {
- r.Failures = make(map[string][]string)
- }
-
- if r.Failures[field] == nil {
- r.Failures[field] = []string{}
+ if r.Errors == nil {
+ r.Errors = make([]ErrorItem, 0)
}
for _, message := range messages {
- r.Failures[field] = append(r.Failures[field], message)
+ r.Errors = append(r.Errors, ErrorItem{
+ Field: field,
+ Message: message,
+ })
+ r.Ok = false
}
- r.Ok = false
}
// Success returns a successful validation
@@ -42,13 +46,15 @@ func Success() *Result {
}
// Failed returns a failed validation result
-func Failed(messages []string) *Result {
- return &Result{Ok: false, Authorized: true, Messages: messages}
+func Failed(messages ...string) *Result {
+ r := &Result{Ok: false, Authorized: true}
+ r.AddFieldFailure("", messages...)
+ return r
}
// Error returns a failed validation result
func Error(err error) *Result {
- return &Result{Ok: false, Authorized: true, Error: err}
+ return &Result{Ok: false, Authorized: true, Err: err}
}
// Unauthorized returns an unauthorized validation result
diff --git a/app/pkg/validate/validation_test.go b/app/pkg/validate/validation_test.go
new file mode 100644
index 000000000..f654c0c20
--- /dev/null
+++ b/app/pkg/validate/validation_test.go
@@ -0,0 +1,52 @@
+package validate_test
+
+import (
+ "errors"
+ "testing"
+
+ . "github.com/getfider/fider/app/pkg/assert"
+ "github.com/getfider/fider/app/pkg/validate"
+)
+
+func TestResult_Error(t *testing.T) {
+ RegisterT(t)
+
+ err := errors.New("Something went wrong...")
+ r := validate.Error(err)
+ Expect(r.Ok).IsFalse()
+ Expect(r.Authorized).IsTrue()
+ Expect(r.Err).Equals(err)
+}
+
+func TestResult_Unauthorized(t *testing.T) {
+ RegisterT(t)
+
+ r := validate.Unauthorized()
+ Expect(r.Ok).IsFalse()
+ Expect(r.Authorized).IsFalse()
+ Expect(r.Errors).HasLen(0)
+ Expect(r.Err).IsNil()
+}
+
+func TestResult_Failed(t *testing.T) {
+ RegisterT(t)
+
+ r := validate.Failed("Error #1", "Error #2")
+ Expect(r.Ok).IsFalse()
+ Expect(r.Authorized).IsTrue()
+ Expect(r.Errors).HasLen(2)
+ Expect(r.Err).IsNil()
+}
+
+func TestResult_AddFieldFailure_Empty(t *testing.T) {
+ RegisterT(t)
+
+ r := validate.Success()
+ r.AddFieldFailure("name")
+ Expect(r.Ok).IsTrue()
+ Expect(r.Errors).HasLen(0)
+
+ r.AddFieldFailure("name", "This field is required")
+ Expect(r.Ok).IsFalse()
+ Expect(r.Errors).HasLen(1)
+}
diff --git a/app/pkg/web/context.go b/app/pkg/web/context.go
index 56a082bac..2264c2245 100644
--- a/app/pkg/web/context.go
+++ b/app/pkg/web/context.go
@@ -230,8 +230,8 @@ func (ctx *Context) Failure(err error) error {
//HandleValidation handles given validation result property to return 400 or 500
func (ctx *Context) HandleValidation(result *validate.Result) error {
- if result.Error != nil {
- return ctx.Failure(result.Error)
+ if result.Err != nil {
+ return ctx.Failure(result.Err)
}
if !result.Authorized {
@@ -239,8 +239,7 @@ func (ctx *Context) HandleValidation(result *validate.Result) error {
}
return ctx.BadRequest(Map{
- "messages": result.Messages,
- "failures": result.Failures,
+ "errors": result.Errors,
})
}
diff --git a/app/pkg/web/oauth.go b/app/pkg/web/oauth.go
index 92ebfc028..94ff68a94 100644
--- a/app/pkg/web/oauth.go
+++ b/app/pkg/web/oauth.go
@@ -189,7 +189,7 @@ func (s *OAuthService) ParseRawProfile(provider, body string) (*oauth.UserProfil
profile.Name = "Anonymous"
}
- if !validate.Email(profile.Email).Ok {
+ if len(validate.Email(profile.Email)) != 0 {
profile.Email = ""
}
diff --git a/public/components/common/form/DisplayError.spec.tsx b/public/components/common/form/DisplayError.spec.tsx
new file mode 100644
index 000000000..cabaae789
--- /dev/null
+++ b/public/components/common/form/DisplayError.spec.tsx
@@ -0,0 +1,78 @@
+import * as React from "react";
+import { shallow } from "enzyme";
+import { DisplayError } from "./DisplayError";
+import { Failure } from "@fider/services";
+
+describe("<DisplayError />", () => {
+ test("when error is undefined", () => {
+ const wrapper = shallow(<DisplayError />);
+ expect(wrapper.getElement()).toBeNull();
+
+ const wrapper1 = shallow(<DisplayError error={{}} />);
+ expect(wrapper1.getElement()).toBeNull();
+ });
+
+ test("when error has only top level messages and fields is empty", () => {
+ const error: Failure = {
+ errors: [{ message: "Something went wrong." }]
+ };
+
+ const wrapper = shallow(<DisplayError error={error} />);
+ const root = wrapper.find("div");
+ expect(root.hasClass("c-form-field-error")).toBe(true);
+ const items = root.find("ul li");
+ expect(items).toHaveLength(1);
+ expect(items.at(0).key()).toBe("Something went wrong.");
+ expect(items.at(0).text()).toBe("Something went wrong.");
+ });
+
+ test("when error has only top level messages and fields is given", () => {
+ const error: Failure = {
+ errors: [{ message: "Something went wrong." }]
+ };
+
+ const wrapper = shallow(<DisplayError error={error} fields={["name"]} />);
+ expect(wrapper.getElement()).toBeNull();
+ });
+
+ test("when error has both field and top level messages and fields are given", () => {
+ const error: Failure = {
+ errors: [
+ { message: "Something went wrong." },
+ { field: "name", message: "Name is required" },
+ { field: "name", message: "Name must have between 0 and 10 chars" },
+ { field: "age", message: "Age must be >= 18" }
+ ]
+ };
+
+ const wrapper1 = shallow(<DisplayError error={error} fields={["name"]} />);
+ const root1 = wrapper1.find("div");
+ expect(root1.hasClass("c-form-field-error")).toBe(true);
+ const items1 = root1.find("ul li");
+ expect(items1).toHaveLength(2);
+ expect(items1.at(0).key()).toBe("Name is required");
+ expect(items1.at(0).text()).toBe("Name is required");
+ expect(items1.at(1).key()).toBe("Name must have between 0 and 10 chars");
+ expect(items1.at(1).text()).toBe("Name must have between 0 and 10 chars");
+
+ const wrapper2 = shallow(<DisplayError error={error} fields={["age"]} />);
+ const root2 = wrapper2.find("div");
+ expect(root2.hasClass("c-form-field-error")).toBe(true);
+ const items2 = root2.find("ul li");
+ expect(items2).toHaveLength(1);
+ expect(items2.at(0).key()).toBe("Age must be >= 18");
+ expect(items2.at(0).text()).toBe("Age must be >= 18");
+
+ const wrapper3 = shallow(<DisplayError error={error} fields={["name", "age"]} />);
+ const root3 = wrapper3.find("div");
+ expect(root3.hasClass("c-form-field-error")).toBe(true);
+ const items3 = root3.find("ul li");
+ expect(items3).toHaveLength(3);
+ expect(items3.at(0).key()).toBe("Name is required");
+ expect(items3.at(0).text()).toBe("Name is required");
+ expect(items3.at(1).key()).toBe("Name must have between 0 and 10 chars");
+ expect(items3.at(1).text()).toBe("Name must have between 0 and 10 chars");
+ expect(items3.at(2).key()).toBe("Age must be >= 18");
+ expect(items3.at(2).text()).toBe("Age must be >= 18");
+ });
+});
diff --git a/public/components/common/form/DisplayError.tsx b/public/components/common/form/DisplayError.tsx
index a3518a78c..947e56bc6 100644
--- a/public/components/common/form/DisplayError.tsx
+++ b/public/components/common/form/DisplayError.tsx
@@ -11,25 +11,38 @@ interface DisplayErrorProps {
}
export const hasError = (field: string, error?: Failure): boolean => {
- if (error && error.failures) {
- return error.failures.hasOwnProperty(field);
+ if (error && error.errors) {
+ for (const err of error.errors) {
+ if (err.field === field) {
+ return true;
+ }
+ }
}
return false;
};
export const DisplayError = (props: DisplayErrorProps) => {
- if (!props.error) {
+ if (!props.error || !props.error.errors) {
return null;
}
+ const dict = props.error.errors.reduce(
+ (result, err) => {
+ result[err.field || ""] = result[err.field || ""] || [];
+ result[err.field || ""].push(err.message);
+ return result;
+ },
+ {} as { [key: string]: string[] }
+ );
+
let items: JSX.Element[] = [];
- if (props.error.messages && !props.fields) {
- items = arrayToTag(props.error.messages);
- } else if (props.error.failures && props.fields) {
- for (const field of props.fields || Object.keys(props.error.failures)) {
- if (props.error.failures.hasOwnProperty(field)) {
- const tags = arrayToTag(props.error.failures[field]);
+ if (dict[""] && !props.fields) {
+ items = arrayToTag(dict[""]);
+ } else if (props.fields) {
+ for (const field of props.fields || Object.keys(dict)) {
+ if (dict.hasOwnProperty(field)) {
+ const tags = arrayToTag(dict[field]);
tags.forEach(t => items.push(t));
}
}
diff --git a/public/pages/Administration/pages/ManageAuthentication.page.tsx b/public/pages/Administration/pages/ManageAuthentication.page.tsx
index 2fc8d3694..d0d722682 100644
--- a/public/pages/Administration/pages/ManageAuthentication.page.tsx
+++ b/public/pages/Administration/pages/ManageAuthentication.page.tsx
@@ -87,9 +87,11 @@ export class ManageAuthenticationPage extends AdminBasePage<
<ListItem key={o.provider}>
{o.isCustomProvider && (
<>
- <Button onClick={this.edit.bind(this, o.provider)} className="right">
- <i className="edit icon" />Edit
- </Button>
+ {Fider.session.user.isAdministrator && (
+ <Button onClick={this.edit.bind(this, o.provider)} className="right">
+ <i className="edit icon" />Edit
+ </Button>
+ )}
<Button onClick={this.startTest.bind(this, o.provider)} className="right">
<i className="play icon" />Test
</Button>
@@ -110,9 +112,11 @@ export class ManageAuthenticationPage extends AdminBasePage<
))}
</List>
</Segment>
- <Button color="positive" onClick={this.addNew}>
- Add new
- </Button>
+ {Fider.session.user.isAdministrator && (
+ <Button color="positive" onClick={this.addNew}>
+ Add new
+ </Button>
+ )}
</>
);
}
diff --git a/public/pages/UI/UIToolkit.page.tsx b/public/pages/UI/UIToolkit.page.tsx
index 1002d26ec..8af72b4eb 100644
--- a/public/pages/UI/UIToolkit.page.tsx
+++ b/public/pages/UI/UIToolkit.page.tsx
@@ -72,12 +72,12 @@ export class UIToolkitPage extends React.Component<{}, UIToolkitPageState> {
private forceError = async () => {
this.setState({
error: {
- messages: [],
- failures: {
- title: ["Title is mandatory"],
- description: ["Error #1", "Error #2"],
- status: ["Status is mandatory"]
- }
+ errors: [
+ { field: "title", message: "Title is mandatory" },
+ { field: "description", message: "Error #1" },
+ { field: "description", message: "Error #2" },
+ { field: "status", message: "Status is mandatory" }
+ ]
}
});
};
diff --git a/public/services/http.ts b/public/services/http.ts
index 98140c7ae..177a68a7d 100644
--- a/public/services/http.ts
+++ b/public/services/http.ts
@@ -1,10 +1,12 @@
import { analytics } from "@fider/services";
+export interface ErrorItem {
+ field?: string;
+ message: string;
+}
+
export interface Failure {
- messages?: string[];
- failures?: {
- [key: string]: string[];
- };
+ errors?: ErrorItem[];
}
export interface Result<T = void> {
@@ -25,8 +27,7 @@ async function toResult<T>(response: Response): Promise<Result<T>> {
ok: false,
data: body as T,
error: {
- messages: body.messages,
- failures: body.failures
+ errors: body.errors
}
};
}