PLT-7: Refactoring manuatesting & utils to use translations (chunk 5)

- Add spanish translations
- Skip tests

5 files changed, 35 insertions, 28 deletions

diff --git a/utils/config.go b/utils/config.go
index c2ae1f7a0..9d2c2f588 100644
--- a/utils/config.go
+++ b/utils/config.go
@@ -118,12 +118,14 @@ func GetLogFileLocation(fileLocation string) string {
 func SaveConfig(fileName string, config *model.Config) *model.AppError {
 	b, err := json.MarshalIndent(config, "", "    ")
 	if err != nil {
-		return model.NewAppError("SaveConfig", "An error occurred while saving the file to "+fileName, err.Error())
+		return model.NewLocAppError("SaveConfig", "utils.config.save_config.saving.app_error",
+			map[string]interface{}{"Filename": fileName}, err.Error())
 	}
 
 	err = ioutil.WriteFile(fileName, b, 0644)
 	if err != nil {
-		return model.NewAppError("SaveConfig", "An error occurred while saving the file to "+fileName, err.Error())
+		return model.NewLocAppError("SaveConfig", "utils.config.save_config.saving.app_error",
+			map[string]interface{}{"Filename": fileName}, err.Error())
 	}
 
 	return nil
@@ -138,18 +140,21 @@ func LoadConfig(fileName string) {
 
 	file, err := os.Open(fileName)
 	if err != nil {
-		panic("Error opening config file=" + fileName + ", err=" + err.Error())
+		panic(T("utils.config.load_config.opening.panic",
+			map[string]interface{}{"Filename": fileName, "Error": err.Error()}))
 	}
 
 	decoder := json.NewDecoder(file)
 	config := model.Config{}
 	err = decoder.Decode(&config)
 	if err != nil {
-		panic("Error decoding config file=" + fileName + ", err=" + err.Error())
+		panic(T("utils.config.load_config.decoding.panic",
+			map[string]interface{}{"Filename": fileName, "Error": err.Error()}))
 	}
 
 	if info, err := file.Stat(); err != nil {
-		panic("Error getting config info file=" + fileName + ", err=" + err.Error())
+		panic(T("utils.config.load_config.getting.panic",
+			map[string]interface{}{"Filename": fileName, "Error": err.Error()}))
 	} else {
 		CfgLastModified = info.ModTime().Unix()
 		CfgFileName = fileName
@@ -158,7 +163,8 @@ func LoadConfig(fileName string) {
 	config.SetDefaults()
 
 	if err := config.IsValid(); err != nil {
-		panic("Error validating config file=" + fileName + ", err=" + err.Message)
+		panic(T("utils.config.load_config.validating.panic",
+			map[string]interface{}{"Filename": fileName, "Error": err.Message}))
 	}
 
 	configureLog(&config.LogSettings)
diff --git a/utils/config_test.go b/utils/config_test.go
index 0b334d36c..6f36b30c3 100644
--- a/utils/config_test.go
+++ b/utils/config_test.go
@@ -9,4 +9,5 @@ import (
 
 func TestConfig(t *testing.T) {
 	LoadConfig("config.json")
+	InitTranslations()
 }
diff --git a/utils/license.go b/utils/license.go
index 4fba94d4d..0d1cd597c 100644
--- a/utils/license.go
+++ b/utils/license.go
@@ -44,7 +44,7 @@ NxpC+5KFhU+xSeeklNqwCgnlOyZ7qSTxmdJHb+60SwuYnnGIYzLJhY4LYDr4J+KR
 func LoadLicense() {
 	file, err := os.Open(LicenseLocation())
 	if err != nil {
-		l4g.Warn("Unable to open/find license file")
+		l4g.Warn(T("utils.license.load_license.open_find.warn"))
 		return
 	}
 	defer file.Close()
@@ -58,7 +58,7 @@ func LoadLicense() {
 		return
 	}
 
-	l4g.Warn("No valid enterprise license found")
+	l4g.Warn(T("utils.license.load_license.invalid.warn"))
 }
 
 func SetLicense(license *model.License) bool {
@@ -84,7 +84,7 @@ func RemoveLicense() bool {
 	ClientLicense = getClientLicense(License)
 
 	if err := os.Remove(LicenseLocation()); err != nil {
-		l4g.Error("Unable to remove license file, err=%v", err.Error())
+		l4g.Error(T("utils.license.remove_license.unable.error"), err.Error())
 		return false
 	}
 
@@ -96,12 +96,12 @@ func ValidateLicense(signed []byte) (bool, string) {
 
 	_, err := base64.StdEncoding.Decode(decoded, signed)
 	if err != nil {
-		l4g.Error("Encountered error decoding license, err=%v", err.Error())
+		l4g.Error(T("utils.license.validate_license.decode.error"), err.Error())
 		return false, ""
 	}
 
 	if len(decoded) <= 256 {
-		l4g.Error("Signed license not long enough")
+		l4g.Error(T("utils.license.validate_license.not_long.error"))
 		return false, ""
 	}
 
@@ -117,7 +117,7 @@ func ValidateLicense(signed []byte) (bool, string) {
 
 	public, err := x509.ParsePKIXPublicKey(block.Bytes)
 	if err != nil {
-		l4g.Error("Encountered error signing license, err=%v", err.Error())
+		l4g.Error(T("utils.license.validate_license.signing.error"), err.Error())
 		return false, ""
 	}
 
@@ -129,7 +129,7 @@ func ValidateLicense(signed []byte) (bool, string) {
 
 	err = rsa.VerifyPKCS1v15(rsaPublic, crypto.SHA512, d, signature)
 	if err != nil {
-		l4g.Error("Invalid signature, err=%v", err.Error())
+		l4g.Error(T("utils.license.validate_license.invalid.error"), err.Error())
 		return false, ""
 	}
 
diff --git a/utils/lru.go b/utils/lru.go
index 61a515e14..f5f7959d8 100644
--- a/utils/lru.go
+++ b/utils/lru.go
@@ -38,7 +38,7 @@ func NewLru(size int) *Cache {
 
 func NewLruWithEvict(size int, onEvicted func(key interface{}, value interface{})) (*Cache, error) {
 	if size <= 0 {
-		return nil, errors.New("Must provide a positive size")
+		return nil, errors.New(T("utils.iru.with_evict"))
 	}
 	c := &Cache{
 		size:      size,
diff --git a/utils/mail.go b/utils/mail.go
index 2f2c10b61..4a0b987e6 100644
--- a/utils/mail.go
+++ b/utils/mail.go
@@ -34,12 +34,12 @@ func connectToSMTPServer(config *model.Config) (net.Conn, *model.AppError) {
 
 		conn, err = tls.Dial("tcp", config.EmailSettings.SMTPServer+":"+config.EmailSettings.SMTPPort, tlsconfig)
 		if err != nil {
-			return nil, model.NewAppError("SendMail", "Failed to open TLS connection", err.Error())
+			return nil, model.NewLocAppError("SendMail", "utils.mail.connect_smtp.open_tls.app_error", nil, err.Error())
 		}
 	} else {
 		conn, err = net.Dial("tcp", config.EmailSettings.SMTPServer+":"+config.EmailSettings.SMTPPort)
 		if err != nil {
-			return nil, model.NewAppError("SendMail", "Failed to open connection", err.Error())
+			return nil, model.NewLocAppError("SendMail", "utils.mail.connect_smtp.open.app_error", nil, err.Error())
 		}
 	}
 
@@ -49,15 +49,15 @@ func connectToSMTPServer(config *model.Config) (net.Conn, *model.AppError) {
 func newSMTPClient(conn net.Conn, config *model.Config) (*smtp.Client, *model.AppError) {
 	c, err := smtp.NewClient(conn, config.EmailSettings.SMTPServer+":"+config.EmailSettings.SMTPPort)
 	if err != nil {
-		l4g.Error("Failed to open a connection to SMTP server %v", err)
-		return nil, model.NewAppError("SendMail", "Failed to open TLS connection", err.Error())
+		l4g.Error(T("utils.mail.new_client.open.error"), err)
+		return nil, model.NewLocAppError("SendMail", "utils.mail.connect_smtp.open_tls.app_error", nil, err.Error())
 	}
 	// GO does not support plain auth over a non encrypted connection.
 	// so if not tls then no auth
 	auth := smtp.PlainAuth("", config.EmailSettings.SMTPUsername, config.EmailSettings.SMTPPassword, config.EmailSettings.SMTPServer+":"+config.EmailSettings.SMTPPort)
 	if config.EmailSettings.ConnectionSecurity == model.CONN_SECURITY_TLS {
 		if err = c.Auth(auth); err != nil {
-			return nil, model.NewAppError("SendMail", "Failed to authenticate on SMTP server", err.Error())
+			return nil, model.NewLocAppError("SendMail", "utils.mail.new_client.auth.app_error", nil, err.Error())
 		}
 	} else if config.EmailSettings.ConnectionSecurity == model.CONN_SECURITY_STARTTLS {
 		tlsconfig := &tls.Config{
@@ -66,7 +66,7 @@ func newSMTPClient(conn net.Conn, config *model.Config) (*smtp.Client, *model.Ap
 		}
 		c.StartTLS(tlsconfig)
 		if err = c.Auth(auth); err != nil {
-			return nil, model.NewAppError("SendMail", "Failed to authenticate on SMTP server", err.Error())
+			return nil, model.NewLocAppError("SendMail", "utils.mail.new_client.auth.app_error", nil, err.Error())
 		}
 	}
 	return c, nil
@@ -79,14 +79,14 @@ func TestConnection(config *model.Config) {
 
 	conn, err1 := connectToSMTPServer(config)
 	if err1 != nil {
-		l4g.Error("SMTP server settings do not appear to be configured properly err=%v details=%v", err1.Message, err1.DetailedError)
+		l4g.Error(T("utils.mail.test.configured.error"), err1.Message, err1.DetailedError)
 		return
 	}
 	defer conn.Close()
 
 	c, err2 := newSMTPClient(conn, config)
 	if err2 != nil {
-		l4g.Error("SMTP connection settings do not appear to be configured properly err=%v details=%v", err2.Message, err2.DetailedError)
+		l4g.Error(T("utils.mail.test.configured.error"), err2.Message, err2.DetailedError)
 		return
 	}
 	defer c.Quit()
@@ -102,7 +102,7 @@ func SendMailUsingConfig(to, subject, body string, config *model.Config) *model.
 		return nil
 	}
 
-	l4g.Debug("sending mail to " + to + " with subject of '" + subject + "'")
+	l4g.Debug(T("utils.mail.send_mail.sending.debug"), to, subject)
 
 	fromMail := mail.Address{config.EmailSettings.FeedbackName, config.EmailSettings.FeedbackEmail}
 	toMail := mail.Address{"", to}
@@ -136,26 +136,26 @@ func SendMailUsingConfig(to, subject, body string, config *model.Config) *model.
 	defer c.Close()
 
 	if err := c.Mail(fromMail.Address); err != nil {
-		return model.NewAppError("SendMail", "Failed to add from email address", err.Error())
+		return model.NewLocAppError("SendMail", "utils.mail.send_mail.from_address.app_error", nil, err.Error())
 	}
 
 	if err := c.Rcpt(toMail.Address); err != nil {
-		return model.NewAppError("SendMail", "Failed to add to email address", err.Error())
+		return model.NewLocAppError("SendMail", "utils.mail.send_mail.to_address.app_error", nil, err.Error())
 	}
 
 	w, err := c.Data()
 	if err != nil {
-		return model.NewAppError("SendMail", "Failed to add email messsage data", err.Error())
+		return model.NewLocAppError("SendMail", "utils.mail.send_mail.msg_data.app_error", nil, err.Error())
 	}
 
 	_, err = w.Write([]byte(message))
 	if err != nil {
-		return model.NewAppError("SendMail", "Failed to write email message", err.Error())
+		return model.NewLocAppError("SendMail", "utils.mail.send_mail.msg.app_error", nil, err.Error())
 	}
 
 	err = w.Close()
 	if err != nil {
-		return model.NewAppError("SendMail", "Failed to close connection to SMTP server", err.Error())
+		return model.NewLocAppError("SendMail", "utils.mail.send_mail.close.app_error", nil, err.Error())
 	}
 
 	return nil