hunk.code_window: func (a *App) regenerateClientConfig() {
   	a.Srv.clientConfig = utils.GenerateClientConfig(a.Config(), a.DiagnosticId(), a.License())
   	if a.Srv.clientConfig["EnableCustomTermsOfService"] == "true" {
   		termsOfService, err := a.GetLatestTermsOfService()
   		if err != nil {
   			mlog.Err(err)
  
hunk.labels: keep keep add keep keep keep keep keep
hunk.after_edit: 	a.Srv.limitedClientConfig = utils.GenerateLimitedClientConfig(a.Config(), a.DiagnosticId(), a.License())
  
hunk.file_path: app/config.go
hunk.type: add
file: // Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
  // See License.txt for license information.
  
  package storetest
  
  import (
  	"fmt"
  	"testing"
  
  	"github.com/mattermost/mattermost-server/model"
  	"github.com/mattermost/mattermost-server/store"
  )
  
  func TestFileInfoStore(t *testing.T, ss store.Store) {
  	t.Run("FileInfoSaveGet", func(t *testing.T) { testFileInfoSaveGet(t, ss) })
  	t.Run("FileInfoSaveGetByPath", func(t *testing.T) { testFileInfoSaveGetByPath(t, ss) })
  	t.Run("FileInfoGetForPost", func(t *testing.T) { testFileInfoGetForPost(t, ss) })
  	t.Run("FileInfoGetForUser", func(t *testing.T) { testFileInfoGetForUser(t, ss) })
  	t.Run("FileInfoAttachToPost", func(t *testing.T) { testFileInfoAttachToPost(t, ss) })
  	t.Run("FileInfoDeleteForPost", func(t *testing.T) { testFileInfoDeleteForPost(t, ss) })
  	t.Run("FileInfoPermanentDelete", func(t *testing.T) { testFileInfoPermanentDelete(t, ss) })
  	t.Run("FileInfoPermanentDeleteBatch", func(t *testing.T) { testFileInfoPermanentDeleteBatch(t, ss) })
  	t.Run("FileInfoPermanentDeleteByUser", func(t *testing.T) { testFileInfoPermanentDeleteByUser(t, ss) })
  }
  
  func testFileInfoSaveGet(t *testing.T, ss store.Store) {
  	info := &model.FileInfo{
  		CreatorId: model.NewId(),
  		Path:      "file.txt",
  	}
  
  	if result := <-ss.FileInfo().Save(info); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.(*model.FileInfo); len(returned.Id) == 0 {
  		t.Fatal("should've assigned an id to FileInfo")
  	} else {
  		info = returned
  	}
  	defer func() {
  		<-ss.FileInfo().PermanentDelete(info.Id)
  	}()
  
  	if result := <-ss.FileInfo().Get(info.Id); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.(*model.FileInfo); returned.Id != info.Id {
  		t.Log(info)
  		t.Log(returned)
  		t.Fatal("should've returned correct FileInfo")
  	}
  
  	info2 := store.Must(ss.FileInfo().Save(&model.FileInfo{
  		CreatorId: model.NewId(),
  		Path:      "file.txt",
  		DeleteAt:  123,
  	})).(*model.FileInfo)
  
  	if result := <-ss.FileInfo().Get(info2.Id); result.Err == nil {
  		t.Fatal("shouldn't have gotten deleted file")
  	}
  	defer func() {
  		<-ss.FileInfo().PermanentDelete(info2.Id)
  	}()
  }
  
  func testFileInfoSaveGetByPath(t *testing.T, ss store.Store) {
  	info := &model.FileInfo{
  		CreatorId: model.NewId(),
  		Path:      fmt.Sprintf("%v/file.txt", model.NewId()),
  	}
  
  	if result := <-ss.FileInfo().Save(info); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.(*model.FileInfo); len(returned.Id) == 0 {
  		t.Fatal("should've assigned an id to FileInfo")
  	} else {
  		info = returned
  	}
  	defer func() {
  		<-ss.FileInfo().PermanentDelete(info.Id)
  	}()
  
  	if result := <-ss.FileInfo().GetByPath(info.Path); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.(*model.FileInfo); returned.Id != info.Id {
  		t.Log(info)
  		t.Log(returned)
  		t.Fatal("should've returned correct FileInfo")
  	}
  
  	info2 := store.Must(ss.FileInfo().Save(&model.FileInfo{
  		CreatorId: model.NewId(),
  		Path:      "file.txt",
  		DeleteAt:  123,
  	})).(*model.FileInfo)
  
  	if result := <-ss.FileInfo().GetByPath(info2.Id); result.Err == nil {
  		t.Fatal("shouldn't have gotten deleted file")
  	}
  	defer func() {
  		<-ss.FileInfo().PermanentDelete(info2.Id)
  	}()
  }
  
  func testFileInfoGetForPost(t *testing.T, ss store.Store) {
  	userId := model.NewId()
  	postId := model.NewId()
  
  	infos := []*model.FileInfo{
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  			DeleteAt:  123,
  		},
  		{
  			PostId:    model.NewId(),
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  	}
  
  	for i, info := range infos {
  		infos[i] = store.Must(ss.FileInfo().Save(info)).(*model.FileInfo)
  		defer func(id string) {
  			<-ss.FileInfo().PermanentDelete(id)
  		}(infos[i].Id)
  	}
  
  	if result := <-ss.FileInfo().GetForPost(postId, true, false); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.([]*model.FileInfo); len(returned) != 2 {
  		t.Fatal("should've returned exactly 2 file infos")
  	}
  
  	if result := <-ss.FileInfo().GetForPost(postId, false, false); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.([]*model.FileInfo); len(returned) != 2 {
  		t.Fatal("should've returned exactly 2 file infos")
  	}
  
  	if result := <-ss.FileInfo().GetForPost(postId, true, true); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.([]*model.FileInfo); len(returned) != 2 {
  		t.Fatal("should've returned exactly 2 file infos")
  	}
  }
  
  func testFileInfoGetForUser(t *testing.T, ss store.Store) {
  	userId := model.NewId()
  	userId2 := model.NewId()
  	postId := model.NewId()
  
  	infos := []*model.FileInfo{
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  		{
  			PostId:    model.NewId(),
  			CreatorId: userId2,
  			Path:      "file.txt",
  		},
  	}
  
  	for i, info := range infos {
  		infos[i] = store.Must(ss.FileInfo().Save(info)).(*model.FileInfo)
  		defer func(id string) {
  			<-ss.FileInfo().PermanentDelete(id)
  		}(infos[i].Id)
  	}
  
  	if result := <-ss.FileInfo().GetForUser(userId); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.([]*model.FileInfo); len(returned) != 3 {
  		t.Fatal("should've returned exactly 3 file infos")
  	}
  
  	if result := <-ss.FileInfo().GetForUser(userId2); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if returned := result.Data.([]*model.FileInfo); len(returned) != 1 {
  		t.Fatal("should've returned exactly 1 file infos")
  	}
  }
  
  func testFileInfoAttachToPost(t *testing.T, ss store.Store) {
  	userId := model.NewId()
  	postId := model.NewId()
  
  	info1 := store.Must(ss.FileInfo().Save(&model.FileInfo{
  		CreatorId: userId,
  		Path:      "file.txt",
  	})).(*model.FileInfo)
  	defer func() {
  		<-ss.FileInfo().PermanentDelete(info1.Id)
  	}()
  
  	if len(info1.PostId) != 0 {
  		t.Fatal("file shouldn't have a PostId")
  	}
  
  	if result := <-ss.FileInfo().AttachToPost(info1.Id, postId); result.Err != nil {
  		t.Fatal(result.Err)
  	} else {
  		info1 = store.Must(ss.FileInfo().Get(info1.Id)).(*model.FileInfo)
  	}
  
  	if len(info1.PostId) == 0 {
  		t.Fatal("file should now have a PostId")
  	}
  
  	info2 := store.Must(ss.FileInfo().Save(&model.FileInfo{
  		CreatorId: userId,
  		Path:      "file.txt",
  	})).(*model.FileInfo)
  	defer func() {
  		<-ss.FileInfo().PermanentDelete(info2.Id)
  	}()
  
  	if result := <-ss.FileInfo().AttachToPost(info2.Id, postId); result.Err != nil {
  		t.Fatal(result.Err)
  	} else {
  		info2 = store.Must(ss.FileInfo().Get(info2.Id)).(*model.FileInfo)
  	}
  
  	if result := <-ss.FileInfo().GetForPost(postId, true, false); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if infos := result.Data.([]*model.FileInfo); len(infos) != 2 {
  		t.Fatal("should've returned exactly 2 file infos")
  	}
  }
  
  func testFileInfoDeleteForPost(t *testing.T, ss store.Store) {
  	userId := model.NewId()
  	postId := model.NewId()
  
  	infos := []*model.FileInfo{
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  		{
  			PostId:    postId,
  			CreatorId: userId,
  			Path:      "file.txt",
  			DeleteAt:  123,
  		},
  		{
  			PostId:    model.NewId(),
  			CreatorId: userId,
  			Path:      "file.txt",
  		},
  	}
  
  	for i, info := range infos {
  		infos[i] = store.Must(ss.FileInfo().Save(info)).(*model.FileInfo)
  		defer func(id string) {
  			<-ss.FileInfo().PermanentDelete(id)
  		}(infos[i].Id)
  	}
  
  	if result := <-ss.FileInfo().DeleteForPost(postId); result.Err != nil {
  		t.Fatal(result.Err)
  	}
  
  	if infos := store.Must(ss.FileInfo().GetForPost(postId, true, false)).([]*model.FileInfo); len(infos) != 0 {
  		t.Fatal("shouldn't have returned any file infos")
  	}
  }
  
  func testFileInfoPermanentDelete(t *testing.T, ss store.Store) {
  	info := store.Must(ss.FileInfo().Save(&model.FileInfo{
  		PostId:    model.NewId(),
  		CreatorId: model.NewId(),
  		Path:      "file.txt",
  	})).(*model.FileInfo)
  
  	if result := <-ss.FileInfo().PermanentDelete(info.Id); result.Err != nil {
  		t.Fatal(result.Err)
  	}
  }
  
  func testFileInfoPermanentDeleteBatch(t *testing.T, ss store.Store) {
  	postId := model.NewId()
  
  	store.Must(ss.FileInfo().Save(&model.FileInfo{
  		PostId:    postId,
  		CreatorId: model.NewId(),
  		Path:      "file.txt",
  		CreateAt:  1000,
  	}))
  
  	store.Must(ss.FileInfo().Save(&model.FileInfo{
  		PostId:    postId,
  		CreatorId: model.NewId(),
  		Path:      "file.txt",
  		CreateAt:  1200,
  	}))
  
  	store.Must(ss.FileInfo().Save(&model.FileInfo{
  		PostId:    postId,
  		CreatorId: model.NewId(),
  		Path:      "file.txt",
  		CreateAt:  2000,
  	}))
  
  	if result := <-ss.FileInfo().GetForPost(postId, true, false); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if len(result.Data.([]*model.FileInfo)) != 3 {
  		t.Fatal("Expected 3 fileInfos")
  	}
  
  	store.Must(ss.FileInfo().PermanentDeleteBatch(1500, 1000))
  
  	if result := <-ss.FileInfo().GetForPost(postId, true, false); result.Err != nil {
  		t.Fatal(result.Err)
  	} else if len(result.Data.([]*model.FileInfo)) != 1 {
  		t.Fatal("Expected 3 fileInfos")
  	}
  }
  
  func testFileInfoPermanentDeleteByUser(t *testing.T, ss store.Store) {
  	userId := model.NewId()
  	postId := model.NewId()
  
  	store.Must(ss.FileInfo().Save(&model.FileInfo{
  		PostId:    postId,
  		CreatorId: userId,
  		Path:      "file.txt",
  	}))
  
  	if result := <-ss.FileInfo().PermanentDeleteByUser(userId); result.Err != nil {
  		t.Fatal(result.Err)
  	}
  }
  