Fix vet issues in model (#20784)

model/command_webhook_test.go

@@ -46,13 +46,13 @@ func TestCommandWebhookIsValid(t *testing.T) {
 	} {
 		tmp := h
 		test.Transform()
-		err := h.IsValid()
+		appErr := h.IsValid()
 
 		if test.ExpectedError == "" {
-			assert.Nil(t, err, "hook should be valid")
+			assert.Nil(t, appErr, "hook should be valid")
 		} else {
-			require.NotNil(t, err)
+			require.NotNil(t, appErr)
-			assert.Equal(t, test.ExpectedError, err.Id, "expected "+test.ExpectedError+" error")
+			assert.Equal(t, test.ExpectedError, appErr.Id, "expected "+test.ExpectedError+" error")
 		}
 
 		h = tmp

model/config.go

@@ -3263,72 +3263,72 @@ func (o *Config) IsValid() *AppError {
 		return NewAppError("Config.IsValid", "model.config.is_valid.allow_cookies_for_subdomains.app_error", nil, "", http.StatusBadRequest)
 	}
 
-	if err := o.TeamSettings.isValid(); err != nil {
+	if appErr := o.TeamSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.SqlSettings.isValid(); err != nil {
+	if appErr := o.SqlSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.FileSettings.isValid(); err != nil {
+	if appErr := o.FileSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.EmailSettings.isValid(); err != nil {
+	if appErr := o.EmailSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.LdapSettings.isValid(); err != nil {
+	if appErr := o.LdapSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.SamlSettings.isValid(); err != nil {
+	if appErr := o.SamlSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
 	if *o.PasswordSettings.MinimumLength < PasswordMinimumLength || *o.PasswordSettings.MinimumLength > PasswordMaximumLength {
 		return NewAppError("Config.IsValid", "model.config.is_valid.password_length.app_error", map[string]any{"MinLength": PasswordMinimumLength, "MaxLength": PasswordMaximumLength}, "", http.StatusBadRequest)
 	}
 
-	if err := o.RateLimitSettings.isValid(); err != nil {
+	if appErr := o.RateLimitSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.ServiceSettings.isValid(); err != nil {
+	if appErr := o.ServiceSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.ElasticsearchSettings.isValid(); err != nil {
+	if appErr := o.ElasticsearchSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.BleveSettings.isValid(); err != nil {
+	if appErr := o.BleveSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.DataRetentionSettings.isValid(); err != nil {
+	if appErr := o.DataRetentionSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.LocalizationSettings.isValid(); err != nil {
+	if appErr := o.LocalizationSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.MessageExportSettings.isValid(); err != nil {
+	if appErr := o.MessageExportSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.DisplaySettings.isValid(); err != nil {
+	if appErr := o.DisplaySettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.ImageProxySettings.isValid(); err != nil {
+	if appErr := o.ImageProxySettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
-	if err := o.ImportSettings.isValid(); err != nil {
+	if appErr := o.ImportSettings.isValid(); appErr != nil {
-		return err
+		return appErr
 	}
 	return nil
 }

model/config_test.go

@@ -159,8 +159,8 @@ func TestConfigIsValidDefaultAlgorithms(t *testing.T) {
 	*c1.SamlSettings.EmailAttribute = "Email"
 	*c1.SamlSettings.UsernameAttribute = "Username"
 
-	err := c1.SamlSettings.isValid()
+	appErr := c1.SamlSettings.isValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 }
 
 func TestConfigServiceProviderDefault(t *testing.T) {
@@ -180,8 +180,8 @@ func TestConfigServiceProviderDefault(t *testing.T) {
 	c1.SetDefaults()
 	assert.Equal(t, *c1.SamlSettings.ServiceProviderIdentifier, *c1.SamlSettings.IdpDescriptorURL)
 
-	err := c1.SamlSettings.isValid()
+	appErr := c1.SamlSettings.isValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 }
 
 func TestConfigIsValidFakeAlgorithm(t *testing.T) {
@@ -202,17 +202,17 @@ func TestConfigIsValidFakeAlgorithm(t *testing.T) {
 
 	temp := *c1.SamlSettings.CanonicalAlgorithm
 	*c1.SamlSettings.CanonicalAlgorithm = "Fake Algorithm"
-	err := c1.SamlSettings.isValid()
+	appErr := c1.SamlSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
-	require.Equal(t, "model.config.is_valid.saml_canonical_algorithm.app_error", err.Message)
+	require.Equal(t, "model.config.is_valid.saml_canonical_algorithm.app_error", appErr.Message)
 	*c1.SamlSettings.CanonicalAlgorithm = temp
 
 	*c1.SamlSettings.SignatureAlgorithm = "Fake Algorithm"
-	err = c1.SamlSettings.isValid()
+	appErr = c1.SamlSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
-	require.Equal(t, "model.config.is_valid.saml_signature_algorithm.app_error", err.Message)
+	require.Equal(t, "model.config.is_valid.saml_signature_algorithm.app_error", appErr.Message)
 }
 
 func TestConfigOverwriteGuestSettings(t *testing.T) {
@@ -794,9 +794,9 @@ func TestDisplaySettingsIsValidCustomURLSchemes(t *testing.T) {
 
 			ds.CustomURLSchemes = test.value
 
-			if err := ds.isValid(); err != nil && test.valid {
+			if appErr := ds.isValid(); appErr != nil && test.valid {
-				t.Error("Expected CustomURLSchemes to be valid but got error:", err)
+				t.Error("Expected CustomURLSchemes to be valid but got error:", appErr)
-			} else if err == nil && !test.valid {
+			} else if appErr == nil && !test.valid {
 				t.Error("Expected CustomURLSchemes to be invalid but got no error")
 			}
 		})
@@ -837,9 +837,9 @@ func TestListenAddressIsValidated(t *testing.T) {
 		if expected {
 			require.Nil(t, ss.isValid(), fmt.Sprintf("Got an error from '%v'.", key))
 		} else {
-			err := ss.isValid()
+			appErr := ss.isValid()
-			require.NotNil(t, err, fmt.Sprintf("Expected '%v' to throw an error.", key))
+			require.NotNil(t, appErr, fmt.Sprintf("Expected '%v' to throw an error.", key))
-			require.Equal(t, "model.config.is_valid.listen_address.app_error", err.Message)
+			require.Equal(t, "model.config.is_valid.listen_address.app_error", appErr.Message)
 		}
 	}
 
@@ -926,11 +926,11 @@ func TestImageProxySettingsIsValid(t *testing.T) {
 				RemoteImageProxyOptions: &test.RemoteImageProxyOptions,
 			}
 
-			err := ips.isValid()
+			appErr := ips.isValid()
 			if test.ExpectError {
-				assert.NotNil(t, err)
+				assert.NotNil(t, appErr)
 			} else {
-				assert.Nil(t, err)
+				assert.Nil(t, appErr)
 			}
 		})
 	}
@@ -1277,11 +1277,11 @@ func TestLdapSettingsIsValid(t *testing.T) {
 		t.Run(test.Name, func(t *testing.T) {
 			test.LdapSettings.SetDefaults()
 
-			err := test.LdapSettings.isValid()
+			appErr := test.LdapSettings.isValid()
 			if test.ExpectError {
-				assert.NotNil(t, err)
+				assert.NotNil(t, appErr)
 			} else {
-				assert.Nil(t, err)
+				assert.Nil(t, appErr)
 			}
 		})
 	}
@@ -1323,7 +1323,7 @@ func TestConfigFilteredByTag(t *testing.T) {
 	// Remove entire sections but the map is still there
 	clusterSettings, ok := cfgMap["SqlSettings"].(map[string]any)
 	require.True(t, ok)
-	require.Equal(t, 0, len(clusterSettings))
+	require.Empty(t, clusterSettings)
 
 	// Some fields are removed if they have the filtering tag
 	serviceSettings, ok := cfgMap["ServiceSettings"].(map[string]any)
@@ -1423,20 +1423,20 @@ func TestConfigImportSettingsIsValid(t *testing.T) {
 	cfg := Config{}
 	cfg.SetDefaults()
 
-	err := cfg.ImportSettings.isValid()
+	appErr := cfg.ImportSettings.isValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 
 	*cfg.ImportSettings.Directory = ""
-	err = cfg.ImportSettings.isValid()
+	appErr = cfg.ImportSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.import.directory.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.import.directory.app_error", appErr.Id)
 
 	cfg.SetDefaults()
 
 	*cfg.ImportSettings.RetentionDays = 0
-	err = cfg.ImportSettings.isValid()
+	appErr = cfg.ImportSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.import.retention_days_too_low.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.import.retention_days_too_low.app_error", appErr.Id)
 }
 
 func TestConfigExportSettingsDefaults(t *testing.T) {
@@ -1451,57 +1451,57 @@ func TestConfigExportSettingsIsValid(t *testing.T) {
 	cfg := Config{}
 	cfg.SetDefaults()
 
-	err := cfg.ExportSettings.isValid()
+	appErr := cfg.ExportSettings.isValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 
 	*cfg.ExportSettings.Directory = ""
-	err = cfg.ExportSettings.isValid()
+	appErr = cfg.ExportSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.export.directory.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.export.directory.app_error", appErr.Id)
 
 	cfg.SetDefaults()
 
 	*cfg.ExportSettings.RetentionDays = 0
-	err = cfg.ExportSettings.isValid()
+	appErr = cfg.ExportSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.export.retention_days_too_low.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.export.retention_days_too_low.app_error", appErr.Id)
 }
 
 func TestConfigServiceSettingsIsValid(t *testing.T) {
 	cfg := Config{}
 	cfg.SetDefaults()
 
-	err := cfg.ServiceSettings.isValid()
+	appErr := cfg.ServiceSettings.isValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 
 	*cfg.ServiceSettings.CollapsedThreads = CollapsedThreadsDisabled
-	err = cfg.ServiceSettings.isValid()
+	appErr = cfg.ServiceSettings.isValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 
 	*cfg.ServiceSettings.ThreadAutoFollow = false
-	err = cfg.ServiceSettings.isValid()
+	appErr = cfg.ServiceSettings.isValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 
 	*cfg.ServiceSettings.CollapsedThreads = CollapsedThreadsDefaultOff
-	err = cfg.ServiceSettings.isValid()
+	appErr = cfg.ServiceSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.collapsed_threads.autofollow.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.collapsed_threads.autofollow.app_error", appErr.Id)
 
 	*cfg.ServiceSettings.CollapsedThreads = CollapsedThreadsDefaultOn
-	err = cfg.ServiceSettings.isValid()
+	appErr = cfg.ServiceSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.collapsed_threads.autofollow.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.collapsed_threads.autofollow.app_error", appErr.Id)
 
 	*cfg.ServiceSettings.CollapsedThreads = CollapsedThreadsAlwaysOn
-	err = cfg.ServiceSettings.isValid()
+	appErr = cfg.ServiceSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.collapsed_threads.autofollow.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.collapsed_threads.autofollow.app_error", appErr.Id)
 
 	*cfg.ServiceSettings.ThreadAutoFollow = true
 	*cfg.ServiceSettings.CollapsedThreads = "test_status"
-	err = cfg.ServiceSettings.isValid()
+	appErr = cfg.ServiceSettings.isValid()
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
-	require.Equal(t, "model.config.is_valid.collapsed_threads.app_error", err.Id)
+	require.Equal(t, "model.config.is_valid.collapsed_threads.app_error", appErr.Id)
 }
 
 func TestConfigDefaultCallsPluginState(t *testing.T) {

model/file_info_test.go

@@ -187,8 +187,8 @@ func TestGetInfoForFile(t *testing.T) {
 
 	for _, tc := range ttc {
 		t.Run(tc.testName, func(t *testing.T) {
-			info, errApp := GetInfoForBytes(tc.filename, bytes.NewReader(tc.file), len(tc.file))
+			info, appErr := GetInfoForBytes(tc.filename, bytes.NewReader(tc.file), len(tc.file))
-			require.Nil(t, errApp)
+			require.Nil(t, appErr)
 
 			assert.Equalf(t, tc.filename, info.Name, "Got incorrect filename: %v", info.Name)
 			assert.Equalf(t, tc.expectedExtension, info.Extension, "Got incorrect extension: %v", info.Extension)

model/group.go

@@ -149,9 +149,9 @@ func (group *Group) Patch(patch *GroupPatch) {
 }
 
 func (group *Group) IsValidForCreate() *AppError {
-	err := group.IsValidName()
+	appErr := group.IsValidName()
-	if err != nil {
+	if appErr != nil {
-		return err
+		return appErr
 	}
 
 	if l := len(group.DisplayName); l == 0 || l > GroupDisplayNameMaxLength {
@@ -199,8 +199,8 @@ func (group *Group) IsValidForUpdate() *AppError {
 	if group.UpdateAt == 0 {
 		return NewAppError("Group.IsValidForUpdate", "model.group.update_at.app_error", nil, "", http.StatusBadRequest)
 	}
-	if err := group.IsValidForCreate(); err != nil {
+	if appErr := group.IsValidForCreate(); appErr != nil {
-		return err
+		return appErr
 	}
 	return nil
 }

model/insights.go

@@ -128,27 +128,30 @@ func TimeRangeToNumberDays(timeRange string) int {
 
 // ChannelPostCountByDuration contains a count of posts by channel id, grouped by ISO8601 date string.
 // Example 1 (grouped by day):
-//  cpc := model.ChannelPostCountByDuration{
+//
-//  	"2009-11-11": {
+//	cpc := model.ChannelPostCountByDuration{
-//  		"ezbp7nqxzjgdir8riodyafr9ww": 90,
+//		"2009-11-11": {
-//  		"p949c1xdojfgzffxma3p3s3ikr": 201,
+//			"ezbp7nqxzjgdir8riodyafr9ww": 90,
-//  	},
+//			"p949c1xdojfgzffxma3p3s3ikr": 201,
-//  	"2009-11-12": {
+//		},
-//  		"ezbp7nqxzjgdir8riodyafr9ww": 45,
+//		"2009-11-12": {
-//  		"p949c1xdojfgzffxma3p3s3ikr": 68,
+//			"ezbp7nqxzjgdir8riodyafr9ww": 45,
-//  	},
+//			"p949c1xdojfgzffxma3p3s3ikr": 68,
-//  }
+//		},
+//	}
+//
 // Example 2 (grouped by hour):
-//  cpc := model.ChannelPostCountByDuration{
+//
-//  	"2009-11-11T01": {
+//	cpc := model.ChannelPostCountByDuration{
-//  		"ezbp7nqxzjgdir8riodyafr9ww": 90,
+//		"2009-11-11T01": {
-//  		"p949c1xdojfgzffxma3p3s3ikr": 201,
+//			"ezbp7nqxzjgdir8riodyafr9ww": 90,
-//  	},
+//			"p949c1xdojfgzffxma3p3s3ikr": 201,
-//  	"2009-11-11T02": {
+//		},
-//  		"ezbp7nqxzjgdir8riodyafr9ww": 45,
+//		"2009-11-11T02": {
-//  		"p949c1xdojfgzffxma3p3s3ikr": 68,
+//			"ezbp7nqxzjgdir8riodyafr9ww": 45,
-//  	},
+//			"p949c1xdojfgzffxma3p3s3ikr": 68,
-//  }
+//		},
+//	}
 type ChannelPostCountByDuration map[string]map[string]int
 
 func blankChannelCountsMap(channelIDs []string) map[string]int {

model/integration_action.go

@@ -271,9 +271,9 @@ func GenerateTriggerId(userId string, s crypto.Signer) (string, string, *AppErro
 }
 
 func (r *PostActionIntegrationRequest) GenerateTriggerId(s crypto.Signer) (string, string, *AppError) {
-	clientTriggerId, triggerId, err := GenerateTriggerId(r.UserId, s)
+	clientTriggerId, triggerId, appErr := GenerateTriggerId(r.UserId, s)
-	if err != nil {
+	if appErr != nil {
-		return "", "", err
+		return "", "", appErr
 	}
 
 	r.TriggerId = triggerId

model/integration_action_test.go

@@ -20,10 +20,10 @@ func TestTriggerIdDecodeAndVerification(t *testing.T) {
 
 	t.Run("should succeed decoding and validation", func(t *testing.T) {
 		userId := NewId()
-		clientTriggerId, triggerId, err := GenerateTriggerId(userId, key)
+		clientTriggerId, triggerId, appErr := GenerateTriggerId(userId, key)
-		require.Nil(t, err)
+		require.Nil(t, appErr)
-		decodedClientTriggerId, decodedUserId, err := DecodeAndVerifyTriggerId(triggerId, key)
+		decodedClientTriggerId, decodedUserId, appErr := DecodeAndVerifyTriggerId(triggerId, key)
-		assert.Nil(t, err)
+		assert.Nil(t, appErr)
 		assert.Equal(t, clientTriggerId, decodedClientTriggerId)
 		assert.Equal(t, userId, decodedUserId)
 	})
@@ -32,53 +32,53 @@ func TestTriggerIdDecodeAndVerification(t *testing.T) {
 		actionReq := &PostActionIntegrationRequest{
 			UserId: NewId(),
 		}
-		clientTriggerId, triggerId, err := actionReq.GenerateTriggerId(key)
+		clientTriggerId, triggerId, appErr := actionReq.GenerateTriggerId(key)
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 		dialogReq := &OpenDialogRequest{TriggerId: triggerId}
-		decodedClientTriggerId, decodedUserId, err := dialogReq.DecodeAndVerifyTriggerId(key)
+		decodedClientTriggerId, decodedUserId, appErr := dialogReq.DecodeAndVerifyTriggerId(key)
-		assert.Nil(t, err)
+		assert.Nil(t, appErr)
 		assert.Equal(t, clientTriggerId, decodedClientTriggerId)
 		assert.Equal(t, actionReq.UserId, decodedUserId)
 	})
 
 	t.Run("should fail on base64 decode", func(t *testing.T) {
-		_, _, err := DecodeAndVerifyTriggerId("junk!", key)
+		_, _, appErr := DecodeAndVerifyTriggerId("junk!", key)
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		assert.Equal(t, "interactive_message.decode_trigger_id.base64_decode_failed", err.Id)
+		assert.Equal(t, "interactive_message.decode_trigger_id.base64_decode_failed", appErr.Id)
 	})
 
 	t.Run("should fail on trigger parsing", func(t *testing.T) {
-		_, _, err := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("junk!")), key)
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("junk!")), key)
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		assert.Equal(t, "interactive_message.decode_trigger_id.missing_data", err.Id)
+		assert.Equal(t, "interactive_message.decode_trigger_id.missing_data", appErr.Id)
 	})
 
 	t.Run("should fail on expired timestamp", func(t *testing.T) {
-		_, _, err := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:1234567890:junksignature")), key)
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:1234567890:junksignature")), key)
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		assert.Equal(t, "interactive_message.decode_trigger_id.expired", err.Id)
+		assert.Equal(t, "interactive_message.decode_trigger_id.expired", appErr.Id)
 	})
 
 	t.Run("should fail on base64 decoding signature", func(t *testing.T) {
-		_, _, err := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:12345678900000:junk!")), key)
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:12345678900000:junk!")), key)
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		assert.Equal(t, "interactive_message.decode_trigger_id.base64_decode_failed_signature", err.Id)
+		assert.Equal(t, "interactive_message.decode_trigger_id.base64_decode_failed_signature", appErr.Id)
 	})
 
 	t.Run("should fail on bad signature", func(t *testing.T) {
-		_, _, err := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:12345678900000:junk")), key)
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:12345678900000:junk")), key)
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		assert.Equal(t, "interactive_message.decode_trigger_id.signature_decode_failed", err.Id)
+		assert.Equal(t, "interactive_message.decode_trigger_id.signature_decode_failed", appErr.Id)
 	})
 
 	t.Run("should fail on bad key", func(t *testing.T) {
-		_, triggerId, err := GenerateTriggerId(NewId(), key)
+		_, triggerId, appErr := GenerateTriggerId(NewId(), key)
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 		newKey, keyErr := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 		require.NoError(t, keyErr)
-		_, _, err = DecodeAndVerifyTriggerId(triggerId, newKey)
+		_, _, appErr = DecodeAndVerifyTriggerId(triggerId, newKey)
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		assert.Equal(t, "interactive_message.decode_trigger_id.verify_signature_failed", err.Id)
+		assert.Equal(t, "interactive_message.decode_trigger_id.verify_signature_failed", appErr.Id)
 	})
 }
 

model/license_test.go

@@ -149,26 +149,26 @@ func TestLicenseRecordIsValid(t *testing.T) {
 		Bytes:    "asdfghjkl;",
 	}
 
-	err := lr.IsValid()
+	appErr := lr.IsValid()
-	assert.NotNil(t, err)
+	assert.NotNil(t, appErr)
 
 	lr.Id = NewId()
 	lr.CreateAt = 0
-	err = lr.IsValid()
+	appErr = lr.IsValid()
-	assert.NotNil(t, err)
+	assert.NotNil(t, appErr)
 
 	lr.CreateAt = GetMillis()
 	lr.Bytes = ""
-	err = lr.IsValid()
+	appErr = lr.IsValid()
-	assert.NotNil(t, err)
+	assert.NotNil(t, appErr)
 
 	lr.Bytes = strings.Repeat("0123456789", 1001)
-	err = lr.IsValid()
+	appErr = lr.IsValid()
-	assert.NotNil(t, err)
+	assert.NotNil(t, appErr)
 
 	lr.Bytes = "ASDFGHJKL;"
-	err = lr.IsValid()
+	appErr = lr.IsValid()
-	assert.Nil(t, err)
+	assert.Nil(t, appErr)
 }
 
 func TestLicenseRecordPreSave(t *testing.T) {

model/link_metadata_test.go

@@ -148,12 +148,12 @@ func TestLinkMetadataIsValid(t *testing.T) {
 		},
 	} {
 		t.Run(test.Name, func(t *testing.T) {
-			err := test.Metadata.IsValid()
+			appErr := test.Metadata.IsValid()
 
 			if test.Expected {
-				assert.Nil(t, err)
+				assert.Nil(t, appErr)
 			} else {
-				assert.NotNil(t, err)
+				assert.NotNil(t, appErr)
 			}
 		})
 	}

model/mention_map_test.go

@@ -112,7 +112,7 @@ func TestUserMentionMap_ToURLValues(t *testing.T) {
 		// check is that the pairs are preserved, which can be checked converting
 		// back to a map with FromURLValues. We check that the test is well-formed
 		// by converting back the expected url.Values too.
-		require.Equal(t, len(actualValues), len(data.expected))
+		require.Len(t, actualValues, len(data.expected))
 
 		actualMentionMap, actualErr := UserMentionMapFromURLValues(actualValues)
 		expectedMentionMap, expectedErr := UserMentionMapFromURLValues(data.expected)
@@ -224,7 +224,7 @@ func TestChannelMentionMap_ToURLValues(t *testing.T) {
 		// check is that the pairs are preserved, which can be checked converting
 		// back to a map with FromURLValues. We check that the test is well-formed
 		// by converting back the expected url.Values too.
-		require.Equal(t, len(actualValues), len(data.expected))
+		require.Len(t, actualValues, len(data.expected))
 
 		actualMentionMap, actualErr := ChannelMentionMapFromURLValues(actualValues)
 		expectedMentionMap, expectedErr := ChannelMentionMapFromURLValues(data.expected)

model/plugin_valid.go

@@ -15,7 +15,8 @@ const (
 )
 
 // ValidId constrains the set of valid plugin identifiers:
-//  ^[a-zA-Z0-9-_\.]+
+//
+//	^[a-zA-Z0-9-_\.]+
 var validId *regexp.Regexp
 
 func init() {

model/post_test.go

@@ -28,50 +28,50 @@ func TestPostIsValid(t *testing.T) {
 	o := Post{}
 	maxPostSize := 10000
 
-	err := o.IsValid(maxPostSize)
+	appErr := o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.Id = NewId()
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.CreateAt = GetMillis()
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.UpdateAt = GetMillis()
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.UserId = NewId()
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.ChannelId = NewId()
 	o.RootId = "123"
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.RootId = ""
 
 	o.Message = strings.Repeat("0", maxPostSize+1)
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.Message = strings.Repeat("0", maxPostSize)
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 
 	o.Message = "test"
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 	o.Type = "junk"
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.NotNil(t, err)
+	require.NotNil(t, appErr)
 
 	o.Type = PostCustomTypePrefix + "type"
-	err = o.IsValid(maxPostSize)
+	appErr = o.IsValid(maxPostSize)
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 }
 
 func TestPostPreSave(t *testing.T) {

model/reaction_test.go

@@ -176,13 +176,13 @@ func TestReactionIsValid(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		err := test.reaction.IsValid()
+		appErr := test.reaction.IsValid()
 		if test.shouldErr {
 			// there should be an error here
-			require.NotNil(t, err, test.errMsg)
+			require.NotNil(t, appErr, test.errMsg)
 		} else {
 			// err should be nil here
-			require.Nil(t, err, test.errMsg)
+			require.Nil(t, appErr, test.errMsg)
 		}
 	}
 }

model/remote_cluster.go

@@ -159,8 +159,8 @@ func (f *RemoteClusterFrame) IsValid() *AppError {
 		return NewAppError("RemoteClusterFrame.IsValid", "api.remote_cluster.invalid_id.app_error", nil, "RemoteId="+f.RemoteId, http.StatusBadRequest)
 	}
 
-	if err := f.Msg.IsValid(); err != nil {
+	if appErr := f.Msg.IsValid(); appErr != nil {
-		return err
+		return appErr
 	}
 
 	return nil

model/remote_cluster_test.go

@@ -33,11 +33,11 @@ func TestRemoteClusterIsValid(t *testing.T) {
 	}
 
 	for _, item := range data {
-		err := item.rc.IsValid()
+		appErr := item.rc.IsValid()
 		if item.valid {
-			assert.Nil(t, err, item.name)
+			assert.Nil(t, appErr, item.name)
 		} else {
-			assert.NotNil(t, err, item.name)
+			assert.NotNil(t, appErr, item.name)
 		}
 	}
 }
@@ -67,11 +67,11 @@ func TestRemoteClusterMsgIsValid(t *testing.T) {
 	}
 
 	for _, item := range data {
-		err := item.msg.IsValid()
+		appErr := item.msg.IsValid()
 		if item.valid {
-			assert.Nil(t, err, item.name)
+			assert.Nil(t, appErr, item.name)
 		} else {
-			assert.NotNil(t, err, item.name)
+			assert.NotNil(t, appErr, item.name)
 		}
 	}
 }

model/search_params_test.go

@@ -1784,17 +1784,17 @@ func TestGetAfterDateMillis(t *testing.T) {
 }
 
 func TestIsSearchParamsListValid(t *testing.T) {
-	var err *AppError
+	var appErr *AppError
 
-	err = IsSearchParamsListValid([]*SearchParams{{IncludeDeletedChannels: true}, {IncludeDeletedChannels: true}})
+	appErr = IsSearchParamsListValid([]*SearchParams{{IncludeDeletedChannels: true}, {IncludeDeletedChannels: true}})
-	assert.Nil(t, err)
+	assert.Nil(t, appErr)
 
-	err = IsSearchParamsListValid([]*SearchParams{{IncludeDeletedChannels: true}, {IncludeDeletedChannels: false}})
+	appErr = IsSearchParamsListValid([]*SearchParams{{IncludeDeletedChannels: true}, {IncludeDeletedChannels: false}})
-	assert.NotNil(t, err)
+	assert.NotNil(t, appErr)
 
-	err = IsSearchParamsListValid([]*SearchParams{{IncludeDeletedChannels: true}})
+	appErr = IsSearchParamsListValid([]*SearchParams{{IncludeDeletedChannels: true}})
-	assert.Nil(t, err)
+	assert.Nil(t, appErr)
 
-	err = IsSearchParamsListValid([]*SearchParams{})
+	appErr = IsSearchParamsListValid([]*SearchParams{})
-	assert.Nil(t, err)
+	assert.Nil(t, appErr)
 }

model/session.go

@@ -34,14 +34,14 @@ const (
 	SessionUserAccessTokenExpiryHours = 100 * 365 * 24 // 100 years
 )
 
-//msgp StringMap
+//msgp:tuple StringMap
 type StringMap map[string]string
 
-//msgp:tuple Session
-
 // Session contains the user session details.
 // This struct's serializer methods are auto-generated. If a new field is added/removed,
 // please run make gen-serialized.
+//
+//msgp:tuple Session
 type Session struct {
 	Id             string        `json:"id"`
 	Token          string        `json:"token"`

model/session_test.go

@@ -62,12 +62,12 @@ func TestSessionIsValid(t *testing.T) {
 
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
-			err := tc.input.IsValid()
+			appErr := tc.input.IsValid()
 			if tc.expectedError != "" {
-				require.NotNil(t, err)
+				require.NotNil(t, appErr)
-				require.Equal(t, tc.expectedError, err.Id)
+				require.Equal(t, tc.expectedError, appErr.Id)
 			} else {
-				require.Nil(t, err)
+				require.Nil(t, appErr)
 			}
 		})
 	}
@@ -98,7 +98,7 @@ func TestSessionDeepCopy(t *testing.T) {
 	session = &Session{TeamMembers: []*TeamMember{}}
 	copySession = session.DeepCopy()
 
-	assert.Equal(t, 0, len(copySession.TeamMembers))
+	assert.Empty(t, copySession.TeamMembers)
 }
 
 func TestSessionCSRF(t *testing.T) {

model/shared_channel_test.go

@@ -37,11 +37,11 @@ func TestSharedChannelIsValid(t *testing.T) {
 	}
 
 	for _, item := range data {
-		err := item.sc.IsValid()
+		appErr := item.sc.IsValid()
 		if item.valid {
-			assert.Nil(t, err, item.name)
+			assert.Nil(t, appErr, item.name)
 		} else {
-			assert.NotNil(t, err, item.name)
+			assert.NotNil(t, appErr, item.name)
 		}
 	}
 }

model/status_test.go

@@ -35,7 +35,7 @@ func TestStatusListToJSON(t *testing.T) {
 		panic(err)
 	}
 
-	assert.Equal(t, len(dat), 2)
+	assert.Len(t, dat, 2)
 
 	_, ok := dat[0]["active_channel"]
 	assert.False(t, ok)

model/team_member.go

@@ -13,9 +13,10 @@ const (
 	USERNAME = "Username"
 )
 
-//msgp:tuple TeamMember
 // This struct's serializer methods are auto-generated. If a new field is added/removed,
 // please run make gen-serialized.
+//
+//msgp:tuple TeamMember
 type TeamMember struct {
 	TeamId        string `json:"team_id"`
 	UserId        string `json:"user_id"`

model/team_test.go

@@ -14,40 +14,40 @@ import (
 func TestTeamIsValid(t *testing.T) {
 	o := Team{}
 
-	err := o.IsValid()
+	appErr := o.IsValid()
-	require.NotNil(t, err, "should be invalid")
+	require.NotNil(t, appErr, "should be invalid")
 
 	o.Id = NewId()
-	err = o.IsValid()
+	appErr = o.IsValid()
-	require.NotNil(t, err, "should be invalid")
+	require.NotNil(t, appErr, "should be invalid")
 
 	o.CreateAt = GetMillis()
-	err = o.IsValid()
+	appErr = o.IsValid()
-	require.NotNil(t, err, "should be invalid")
+	require.NotNil(t, appErr, "should be invalid")
 
 	o.UpdateAt = GetMillis()
-	err = o.IsValid()
+	appErr = o.IsValid()
-	require.NotNil(t, err, "should be invalid")
+	require.NotNil(t, appErr, "should be invalid")
 
 	o.Email = strings.Repeat("01234567890", 20)
-	err = o.IsValid()
+	appErr = o.IsValid()
-	require.NotNil(t, err, "should be invalid")
+	require.NotNil(t, appErr, "should be invalid")
 
 	o.Email = "corey+test@hulen.com"
 	o.DisplayName = strings.Repeat("01234567890", 20)
-	err = o.IsValid()
+	appErr = o.IsValid()
-	require.NotNil(t, err, "should be invalid")
+	require.NotNil(t, appErr, "should be invalid")
 
 	o.DisplayName = "1234"
 	o.Name = "ZZZZZZZ"
-	err = o.IsValid()
+	appErr = o.IsValid()
-	require.NotNil(t, err, "should be invalid")
+	require.NotNil(t, appErr, "should be invalid")
 
 	o.Name = "zzzzz"
 	o.Type = TeamOpen
 	o.InviteId = NewId()
-	err = o.IsValid()
+	appErr = o.IsValid()
-	require.Nil(t, err, err)
+	require.Nil(t, appErr, appErr)
 }
 
 func TestTeamPreSave(t *testing.T) {

model/upload_session_test.go

@@ -13,8 +13,8 @@ func TestUploadSessionIsValid(t *testing.T) {
 	var session UploadSession
 
 	t.Run("empty session should fail", func(t *testing.T) {
-		err := session.IsValid()
+		appErr := session.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
 	})
 
 	t.Run("valid session should succeed", func(t *testing.T) {
@@ -29,97 +29,97 @@ func TestUploadSessionIsValid(t *testing.T) {
 			FileSize:   1024,
 			FileOffset: 0,
 		}
-		err := session.IsValid()
+		appErr := session.IsValid()
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 	})
 
 	t.Run("invalid Id should fail", func(t *testing.T) {
 		us := session
 		us.Id = "invalid"
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.id.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.id.app_error", appErr.Id)
 	})
 
 	t.Run("invalid type should fail", func(t *testing.T) {
 		us := session
 		us.Type = "invalid"
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.type.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.type.app_error", appErr.Id)
 	})
 
 	t.Run("invalid CreateAt should fail", func(t *testing.T) {
 		us := session
 		us.CreateAt = 0
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.create_at.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.create_at.app_error", appErr.Id)
 	})
 
 	t.Run("invalid UserId should fail", func(t *testing.T) {
 		us := session
 		us.UserId = "invalid"
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.user_id.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.user_id.app_error", appErr.Id)
 	})
 
 	t.Run("invalid ChannelId should fail", func(t *testing.T) {
 		us := session
 		us.ChannelId = "invalid"
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.channel_id.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.channel_id.app_error", appErr.Id)
 	})
 
 	t.Run("ChannelId is not validated if type is not attachment", func(t *testing.T) {
 		us := session
 		us.ChannelId = ""
 		us.Type = UploadTypeImport
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 	})
 
 	t.Run("invalid Filename should fail", func(t *testing.T) {
 		us := session
 		us.Filename = ""
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.filename.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.filename.app_error", appErr.Id)
 	})
 
 	t.Run("invalid Path should fail", func(t *testing.T) {
 		us := session
 		us.Path = ""
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.path.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.path.app_error", appErr.Id)
 	})
 
 	t.Run("invalid FileSize should fail", func(t *testing.T) {
 		us := session
 		us.FileSize = 0
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.file_size.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.file_size.app_error", appErr.Id)
 
 		us.FileSize = -1
-		err = us.IsValid()
+		appErr = us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.file_size.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.file_size.app_error", appErr.Id)
 	})
 
 	t.Run("invalid FileOffset should fail", func(t *testing.T) {
 		us := session
 		us.FileOffset = us.FileSize + 1
-		err := us.IsValid()
+		appErr := us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.file_offset.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.file_offset.app_error", appErr.Id)
 
 		us.FileOffset = -1
-		err = us.IsValid()
+		appErr = us.IsValid()
-		require.NotNil(t, err)
+		require.NotNil(t, appErr)
-		require.Equal(t, "model.upload_session.is_valid.file_offset.app_error", err.Id)
+		require.Equal(t, "model.upload_session.is_valid.file_offset.app_error", appErr.Id)
 	})
 }

model/user_access_token_test.go

@@ -12,21 +12,21 @@ import (
 func TestUserAccessTokenIsValid(t *testing.T) {
 	ad := UserAccessToken{}
 
-	err := ad.IsValid()
+	appErr := ad.IsValid()
-	require.False(t, err == nil || err.Id != "model.user_access_token.is_valid.id.app_error")
+	require.False(t, appErr == nil || appErr.Id != "model.user_access_token.is_valid.id.app_error")
 
 	ad.Id = NewRandomString(26)
-	err = ad.IsValid()
+	appErr = ad.IsValid()
-	require.False(t, err == nil || err.Id != "model.user_access_token.is_valid.token.app_error")
+	require.False(t, appErr == nil || appErr.Id != "model.user_access_token.is_valid.token.app_error")
 
 	ad.Token = NewRandomString(26)
-	err = ad.IsValid()
+	appErr = ad.IsValid()
-	require.False(t, err == nil || err.Id != "model.user_access_token.is_valid.user_id.app_error")
+	require.False(t, appErr == nil || appErr.Id != "model.user_access_token.is_valid.user_id.app_error")
 
 	ad.UserId = NewRandomString(26)
 	require.Nil(t, ad.IsValid())
 
 	ad.Description = NewRandomString(256)
-	err = ad.IsValid()
+	appErr = ad.IsValid()
-	require.False(t, err == nil || err.Id != "model.user_access_token.is_valid.description.app_error")
+	require.False(t, appErr == nil || appErr.Id != "model.user_access_token.is_valid.description.app_error")
 }

model/user_test.go

@@ -76,38 +76,38 @@ func TestUserUpdateMentionKeysFromUsername(t *testing.T) {
 
 func TestUserIsValid(t *testing.T) {
 	user := User{}
-	err := user.IsValid()
+	appErr := user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "id", ""), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "id", ""), "expected user is valid error: %s", appErr.Error())
 
 	user.Id = NewId()
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "create_at", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "create_at", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.CreateAt = GetMillis()
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "update_at", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "update_at", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.UpdateAt = GetMillis()
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "username", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "username", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.Username = NewId() + "^hello#"
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "username", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "username", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.Username = NewId()
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "email", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "email", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.Email = strings.Repeat("01234567890", 20)
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "email", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "email", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.Email = "user@example.com"
 
 	user.Nickname = strings.Repeat("a", 65)
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "nickname", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "nickname", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.Nickname = strings.Repeat("a", 64)
 	require.Nil(t, user.IsValid())
@@ -117,30 +117,30 @@ func TestUserIsValid(t *testing.T) {
 	require.Nil(t, user.IsValid())
 
 	user.FirstName = strings.Repeat("a", 65)
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "first_name", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "first_name", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.FirstName = strings.Repeat("a", 64)
 	user.LastName = strings.Repeat("a", 65)
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "last_name", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "last_name", user.Id), "expected user is valid error: %s", appErr.Error())
 
 	user.LastName = strings.Repeat("a", 64)
 	user.Position = strings.Repeat("a", 128)
 	require.Nil(t, user.IsValid())
 
 	user.Position = strings.Repeat("a", 129)
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "position", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "position", user.Id), "expected user is valid error: %s", appErr.Error())
 	user.Position = ""
 
 	user.Roles = strings.Repeat("a", UserRolesMaxLength)
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 
 	user.Roles = strings.Repeat("a", UserRolesMaxLength+1)
-	err = user.IsValid()
+	appErr = user.IsValid()
-	require.True(t, HasExpectedUserIsValidError(err, "roles_limit", user.Id), "expected user is valid error: %s", err.Error())
+	require.True(t, HasExpectedUserIsValidError(appErr, "roles_limit", user.Id), "expected user is valid error: %s", appErr.Error())
 }
 
 func HasExpectedUserIsValidError(err *AppError, fieldName string, userId string) bool {
@@ -261,7 +261,7 @@ func TestCleanUsername(t *testing.T) {
 	assert.Equal(t, CleanUsername("PUNCH"), "punch", "didn't clean name properly")
 	assert.Equal(t, CleanUsername("spin'punch"), "spin-punch", "didn't clean name properly")
 	assert.Equal(t, CleanUsername("spin"), "spin", "didn't clean name properly")
-	assert.Equal(t, len(CleanUsername("all")), 27, "didn't clean name properly")
+	assert.Len(t, CleanUsername("all"), 27, "didn't clean name properly")
 }
 
 func TestRoles(t *testing.T) {
@@ -338,18 +338,18 @@ func TestUserSlice(t *testing.T) {
 		slice := UserSlice([]*User{user0, user1, user2})
 
 		activeUsers := slice.FilterByActive(true)
-		assert.Equal(t, 2, len(activeUsers))
+		assert.Len(t, activeUsers, 2)
 		for _, user := range activeUsers {
 			assert.True(t, user.DeleteAt == 0)
 		}
 
 		inactiveUsers := slice.FilterByActive(false)
-		assert.Equal(t, 1, len(inactiveUsers))
+		assert.Len(t, inactiveUsers, 1)
 		for _, user := range inactiveUsers {
 			assert.True(t, user.DeleteAt != 0)
 		}
 
 		nonBotUsers := slice.FilterWithoutBots()
-		assert.Equal(t, 1, len(nonBotUsers))
+		assert.Len(t, nonBotUsers, 1)
 	})
 }

model/utils_test.go

@@ -73,12 +73,12 @@ func TestPadDateStringZeros(t *testing.T) {
 }
 
 func TestAppError(t *testing.T) {
-	err := NewAppError("TestAppError", "message", nil, "", http.StatusInternalServerError)
+	appErr := NewAppError("TestAppError", "message", nil, "", http.StatusInternalServerError)
-	json := err.ToJSON()
+	json := appErr.ToJSON()
 	rerr := AppErrorFromJSON(strings.NewReader(json))
-	require.Equal(t, err.Message, rerr.Message)
+	require.Equal(t, appErr.Message, rerr.Message)
 
-	t.Log(err.Error())
+	t.Log(appErr.Error())
 }
 
 func TestAppErrorJunk(t *testing.T) {

shared/filestore/filesstore_test.go

@@ -528,7 +528,7 @@ func BenchmarkS3WriteFile(b *testing.B) {
 		written, err := backend.WriteFile(bytes.NewReader(data), path)
 		defer backend.RemoveFile(path)
 		require.NoError(b, err)
-		require.Equal(b, len(data), int(written))
+		require.Len(b, data, int(written))
 	}
 
 	b.StopTimer()