Remove unused variables / code (#7736)

* remove unused variables / code

* fix bug in testPostStoreGetOldest

api/context.go

@@ -32,7 +32,6 @@ type Context struct {
 	T             goi18n.TranslateFunc
 	Locale        string
 	TeamId        string
-	isSystemAdmin bool
 }
 
 func (api *API) ApiAppHandler(h func(*Context, http.ResponseWriter, *http.Request)) http.Handler {

api/emoji.go

@@ -192,10 +192,6 @@ func getEmojiImage(c *Context, w http.ResponseWriter, r *http.Request) {
 	w.Write(image)
 }
 
-func getEmojiImagePath(id string) string {
-	return "emoji/" + id + "/image"
-}
-
 func resizeEmoji(img image.Image, width int, height int) image.Image {
 	emojiWidth := float64(width)
 	emojiHeight := float64(height)

cmd/platform/cmdtestlib.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2017-present Mattermost, Inc. All Rights Reserved.
-// See License.txt for license information.
-
-package main
-
-import (
-	"bytes"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-func runCommand(argString string) error {
-	err, _ := runCommandWithOutput(argString)
-
-	return err
-}
-
-func runCommandWithOutput(argString string) (error, string) {
-	// Set arguments on the root command
-	rootCmd.SetArgs(strings.Split(argString, " "))
-	defer rootCmd.SetArgs([]string{})
-
-	output := new(bytes.Buffer)
-	rootCmd.SetOutput(output)
-	defer rootCmd.SetOutput(nil)
-
-	// Executing the root command will call the necessary subcommand
-	cmd, err := rootCmd.ExecuteC()
-
-	// And clear the arguments on the subcommand that was actually called since they'd otherwise
-	// be used on the next call to this command
-	clearArgs(cmd)
-
-	return err, output.String()
-}
-
-func clearArgs(command *cobra.Command) {
-	command.Flags().VisitAll(clearFlag)
-}
-
-func clearFlag(flag *pflag.Flag) {
-	flag.Value.Set(flag.DefValue)
-}

cmd/platform/output.go

@@ -11,22 +11,10 @@ func CommandPrintln(a ...interface{}) (int, error) {
 	return fmt.Println(a...)
 }
 
-func CommandPrint(a ...interface{}) (int, error) {
-	return fmt.Print(a...)
-}
-
 func CommandPrintErrorln(a ...interface{}) (int, error) {
 	return fmt.Fprintln(os.Stderr, a...)
 }
 
-func CommandPrintError(a ...interface{}) (int, error) {
-	return fmt.Fprint(os.Stderr, a...)
-}
-
 func CommandPrettyPrintln(a ...interface{}) (int, error) {
 	return fmt.Fprintln(os.Stderr, a...)
 }
-
-func CommandPrettyPrint(a ...interface{}) (int, error) {
-	return fmt.Fprint(os.Stderr, a...)
-}

model/config.go

@@ -586,10 +586,6 @@ func (o *Config) GetSSOService(service string) *SSOSettings {
 	return nil
 }
 
-func (o *Config) getClientRequirementsFromConfig() ClientRequirements {
-	return o.ClientRequirements
-}
-
 func ConfigFromJson(data io.Reader) *Config {
 	decoder := json.NewDecoder(data)
 	var o Config

plugin/rpcplugin/muxer.go

@@ -223,7 +223,6 @@ type muxerStream struct {
 	readWake     *sync.Cond
 	isClosed     bool
 	remoteClosed bool
-	closeErr     error
 }
 
 func (s *muxerStream) Read(p []byte) (int, error) {

store/layered_store_hints.go

@@ -18,14 +18,3 @@ func hintsContains(hints []LayeredStoreHint, contains LayeredStoreHint) bool {
 	}
 	return false
 }
-
-func hintsContainsAny(hints []LayeredStoreHint, contains ...LayeredStoreHint) bool {
-	for _, hint := range hints {
-		for _, hint2 := range contains {
-			if hint == hint2 {
-				return true
-			}
-		}
-	}
-	return false
-}

store/sqlstore/channel_store.go

@@ -420,11 +420,6 @@ func (s SqlChannelStore) PermanentDeleteMembersByChannel(channelId string) store
 	})
 }
 
-type channelWithMember struct {
-	model.Channel
-	model.ChannelMember
-}
-
 func (s SqlChannelStore) GetChannels(teamId string, userId string) store.StoreChannel {
 	return store.Do(func(result *store.StoreResult) {
 		data := &model.ChannelList{}

store/storetest/post_store.go

@@ -41,6 +41,7 @@ func TestPostStore(t *testing.T, ss store.Store) {
 	t.Run("GetPostsByIds", func(t *testing.T) { testPostStoreGetPostsByIds(t, ss) })
 	t.Run("GetPostsBatchForIndexing", func(t *testing.T) { testPostStoreGetPostsBatchForIndexing(t, ss) })
 	t.Run("PermanentDeleteBatch", func(t *testing.T) { testPostStorePermanentDeleteBatch(t, ss) })
+	t.Run("GetOldest", func(t *testing.T) { testPostStoreGetOldest(t, ss) })
 }
 
 func testPostStoreSave(t *testing.T, ss store.Store) {
@@ -1700,7 +1701,6 @@ func testPostStoreGetOldest(t *testing.T, ss store.Store) {
 	o1 = (<-ss.Post().Save(o1)).Data.(*model.Post)
 
 	o2 := &model.Post{}
-	o2.Id = model.NewId()
 	o2.ChannelId = o1.ChannelId
 	o2.UserId = model.NewId()
 	o2.Message = "zz" + model.NewId() + "b"

utils/logger/logger.go

@@ -28,15 +28,14 @@ var infoLog = l4g.Info
 var errorLog = l4g.Error
 
 func init() {
+	// listens for configuration changes that we might need to respond to
+	utils.AddConfigListener(func(oldConfig *model.Config, newConfig *model.Config) {
+		infoLog("Configuration change detected, reloading log settings")
+		initL4g(newConfig.LogSettings)
+	})
 	initL4g(utils.Cfg.LogSettings)
 }
 
-// listens for configuration changes that we might need to respond to
-var configListenerID = utils.AddConfigListener(func(oldConfig *model.Config, newConfig *model.Config) {
-	infoLog("Configuration change detected, reloading log settings")
-	initL4g(newConfig.LogSettings)
-})
-
 // assumes that ../config.go::configureLog has already been called, and has in turn called l4g.close() to clean up
 // any old filters that we might have previously created
 func initL4g(logSettings model.LogSettings) {

utils/logger/logger_test.go

@@ -1,281 +0,0 @@
-// this is a new logger interface for mattermost
-
-package logger
-
-type LogMessage struct {
-	Context map[string]string
-	File    string
-	Message string
-}
-
-const validPath = `^utils/([a-z_]+/)*logger_test.go$`
-
-/*
-
-Broken because code somehow depends on path
-
-// ensures that the relative path of the file that called into the logger is returned
-func TestGetCallerFilename(t *testing.T) {
-	filename, _ := getCallerFilename()
-	fmt.Println("Thing: " + filename)
-	matched, err := regexp.MatchString(validPath, filename)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that values can be recorded on a Context object, and that the data in question is serialized as a part of the log message
-func TestSerializeContext(t *testing.T) {
-	ctx := context.Background()
-
-	expectedUserId := "some-fake-user-id"
-	ctx = WithUserId(ctx, expectedUserId)
-
-	expectedRequestId := "some-fake-request-id"
-	ctx = WithRequestId(ctx, expectedRequestId)
-
-	serialized := serializeContext(ctx)
-
-	assert.Equal(t, map[string]string{
-		"user_id":    expectedUserId,
-		"request_id": expectedRequestId,
-	}, serialized)
-}
-
-// ensures that an entire log message with an empty context can be properly serialized into a JSON object
-func TestSerializeLogMessageEmptyContext(t *testing.T) {
-	emptyContext := context.Background()
-
-	var logMessage = "This is a log message"
-	var serialized = serializeLogMessage(emptyContext, logMessage)
-
-	var deserialized LogMessage
-	json.Unmarshal([]byte(serialized), &deserialized)
-
-	assert.Empty(t, deserialized.Context)
-	assert.Equal(t, logMessage, deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that an entire log message with a populated context can be properly serialized into a JSON object
-func TestSerializeLogMessagePopulatedContext(t *testing.T) {
-	populatedContext := context.Background()
-
-	populatedContext = WithRequestId(populatedContext, "foo")
-	populatedContext = WithUserId(populatedContext, "bar")
-
-	var logMessage = "This is a log message"
-	var serialized = serializeLogMessage(populatedContext, logMessage)
-
-	var deserialized LogMessage
-	json.Unmarshal([]byte(serialized), &deserialized)
-
-	assert.Equal(t, map[string]string{
-		"request_id": "foo",
-		"user_id":    "bar",
-	}, deserialized.Context)
-	assert.Equal(t, logMessage, deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that a debugLog message is passed through to the underlying logger as expected
-func TestDebugc(t *testing.T) {
-	// inject a "mocked" debugLog method that captures the first argument that is passed to it
-	var capture string
-	oldDebug := debugLog
-	defer func() { debugLog = oldDebug }()
-	type WrapperType func() string
-	debugLog = func(format interface{}, args ...interface{}) {
-		// the code that we're testing passes a closure to the debugLog method, so we have to execute it to get the actual message back
-		if f, ok := format.(func() string); ok {
-			capture = WrapperType(f)()
-		} else {
-			t.Error("First parameter passed to Debug is not a closure")
-		}
-	}
-
-	// log something
-	emptyContext := context.Background()
-	var logMessage = "Some log message"
-	Debugc(emptyContext, logMessage)
-
-	// check to see that the message is logged to the underlying log system, in this case our mock method
-	var deserialized LogMessage
-	json.Unmarshal([]byte(capture), &deserialized)
-
-	assert.Empty(t, deserialized.Context)
-	assert.Equal(t, logMessage, deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that a debugLog message is passed through to the underlying logger as expected
-func TestDebugf(t *testing.T) {
-	// inject a "mocked" debugLog method that captures the first argument that is passed to it
-	var capture string
-	oldDebug := debugLog
-	defer func() { debugLog = oldDebug }()
-	type WrapperType func() string
-	debugLog = func(format interface{}, args ...interface{}) {
-		// the code that we're testing passes a closure to the debugLog method, so we have to execute it to get the actual message back
-		if f, ok := format.(func() string); ok {
-			capture = WrapperType(f)()
-		} else {
-			t.Error("First parameter passed to Debug is not a closure")
-		}
-	}
-
-	// log something
-	formatString := "Some %v message"
-	param := "log"
-	Debugf(formatString, param)
-
-	// check to see that the message is logged to the underlying log system, in this case our mock method
-	var deserialized LogMessage
-	json.Unmarshal([]byte(capture), &deserialized)
-
-	assert.Empty(t, deserialized.Context)
-	assert.Equal(t, fmt.Sprintf(formatString, param), deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that an infoLog message is passed through to the underlying logger as expected
-func TestInfoc(t *testing.T) {
-	// inject a "mocked" infoLog method that captures the first argument that is passed to it
-	var capture string
-	oldInfo := infoLog
-	defer func() { infoLog = oldInfo }()
-	type WrapperType func() string
-	infoLog = func(format interface{}, args ...interface{}) {
-		// the code that we're testing passes a closure to the infoLog method, so we have to execute it to get the actual message back
-		if f, ok := format.(func() string); ok {
-			capture = WrapperType(f)()
-		} else {
-			t.Error("First parameter passed to Info is not a closure")
-		}
-	}
-
-	// log something
-	emptyContext := context.Background()
-	var logMessage = "Some log message"
-	Infoc(emptyContext, logMessage)
-
-	// check to see that the message is logged to the underlying log system, in this case our mock method
-	var deserialized LogMessage
-	json.Unmarshal([]byte(capture), &deserialized)
-
-	assert.Empty(t, deserialized.Context)
-	assert.Equal(t, logMessage, deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that an infoLog message is passed through to the underlying logger as expected
-func TestInfof(t *testing.T) {
-	// inject a "mocked" infoLog method that captures the first argument that is passed to it
-	var capture string
-	oldInfo := infoLog
-	defer func() { infoLog = oldInfo }()
-	type WrapperType func() string
-	infoLog = func(format interface{}, args ...interface{}) {
-		// the code that we're testing passes a closure to the infoLog method, so we have to execute it to get the actual message back
-		if f, ok := format.(func() string); ok {
-			capture = WrapperType(f)()
-		} else {
-			t.Error("First parameter passed to Info is not a closure")
-		}
-	}
-
-	// log something
-	format := "Some %v message"
-	param := "log"
-	Infof(format, param)
-
-	// check to see that the message is logged to the underlying log system, in this case our mock method
-	var deserialized LogMessage
-	json.Unmarshal([]byte(capture), &deserialized)
-
-	assert.Empty(t, deserialized.Context)
-	assert.Equal(t, fmt.Sprintf(format, param), deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that an error message is passed through to the underlying logger as expected
-func TestErrorc(t *testing.T) {
-	// inject a "mocked" err method that captures the first argument that is passed to it
-	var capture string
-	oldError := errorLog
-	defer func() { errorLog = oldError }()
-	type WrapperType func() string
-	errorLog = func(format interface{}, args ...interface{}) error {
-		// the code that we're testing passes a closure to the err method, so we have to execute it to get the actual message back
-		if f, ok := format.(func() string); ok {
-			capture = WrapperType(f)()
-		} else {
-			t.Error("First parameter passed to Error is not a closure")
-		}
-
-		// the code under test doesn't care about this return value
-		return errors.New(capture)
-	}
-
-	// log something
-	emptyContext := context.Background()
-	var logMessage = "Some log message"
-	Errorc(emptyContext, logMessage)
-
-	// check to see that the message is logged to the underlying log system, in this case our mock method
-	var deserialized LogMessage
-	json.Unmarshal([]byte(capture), &deserialized)
-
-	assert.Empty(t, deserialized.Context)
-	assert.Equal(t, logMessage, deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-
-// ensures that an error message is passed through to the underlying logger as expected
-func TestErrorf(t *testing.T) {
-	// inject a "mocked" err method that captures the first argument that is passed to it
-	var capture string
-	oldError := errorLog
-	defer func() { errorLog = oldError }()
-	type WrapperType func() string
-	errorLog = func(format interface{}, args ...interface{}) error {
-		// the code that we're testing passes a closure to the err method, so we have to execute it to get the actual message back
-		if f, ok := format.(func() string); ok {
-			capture = WrapperType(f)()
-		} else {
-			t.Error("First parameter passed to Error is not a closure")
-		}
-
-		// the code under test doesn't care about this return value
-		return errors.New(capture)
-	}
-
-	// log something
-	format := "Some %v message"
-	param := "log"
-	Errorf(format, param)
-
-	// check to see that the message is logged to the underlying log system, in this case our mock method
-	var deserialized LogMessage
-	json.Unmarshal([]byte(capture), &deserialized)
-
-	assert.Empty(t, deserialized.Context)
-	assert.Equal(t, fmt.Sprintf(format, param), deserialized.Message)
-	matched, err := regexp.MatchString(validPath, deserialized.File)
-	require.NoError(t, err)
-	assert.True(t, matched)
-}
-*/