github.com/mattermosttest/mattermost-server/v5@v5.0.0-20200917143240-9dfa12e121f9/services/filesstore/filesstore_test.go (about)

     1  // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
     2  // See LICENSE.txt for license information.
     3  
     4  package filesstore
     5  
     6  import (
     7  	"bytes"
     8  	"fmt"
     9  	"io/ioutil"
    10  	"os"
    11  	"testing"
    12  
    13  	"github.com/stretchr/testify/require"
    14  	"github.com/stretchr/testify/suite"
    15  
    16  	"github.com/mattermost/mattermost-server/v5/mlog"
    17  	"github.com/mattermost/mattermost-server/v5/model"
    18  	"github.com/mattermost/mattermost-server/v5/utils"
    19  )
    20  
    21  type FileBackendTestSuite struct {
    22  	suite.Suite
    23  
    24  	settings model.FileSettings
    25  	backend  FileBackend
    26  }
    27  
    28  func TestLocalFileBackendTestSuite(t *testing.T) {
    29  	// Setup a global logger to catch tests logging outside of app context
    30  	// The global logger will be stomped by apps initializing but that's fine for testing. Ideally this won't happen.
    31  	mlog.InitGlobalLogger(mlog.NewLogger(&mlog.LoggerConfiguration{
    32  		EnableConsole: true,
    33  		ConsoleJson:   true,
    34  		ConsoleLevel:  "error",
    35  		EnableFile:    false,
    36  	}))
    37  
    38  	dir, err := ioutil.TempDir("", "")
    39  	require.NoError(t, err)
    40  	defer os.RemoveAll(dir)
    41  
    42  	suite.Run(t, &FileBackendTestSuite{
    43  		settings: model.FileSettings{
    44  			DriverName: model.NewString(model.IMAGE_DRIVER_LOCAL),
    45  			Directory:  &dir,
    46  		},
    47  	})
    48  }
    49  
    50  func TestS3FileBackendTestSuite(t *testing.T) {
    51  	runBackendTest(t, false)
    52  }
    53  
    54  func TestS3FileBackendTestSuiteWithEncryption(t *testing.T) {
    55  	runBackendTest(t, true)
    56  }
    57  
    58  func runBackendTest(t *testing.T, encrypt bool) {
    59  	s3Host := os.Getenv("CI_MINIO_HOST")
    60  	if s3Host == "" {
    61  		s3Host = "localhost"
    62  	}
    63  
    64  	s3Port := os.Getenv("CI_MINIO_PORT")
    65  	if s3Port == "" {
    66  		s3Port = "9000"
    67  	}
    68  
    69  	s3Endpoint := fmt.Sprintf("%s:%s", s3Host, s3Port)
    70  
    71  	suite.Run(t, &FileBackendTestSuite{
    72  		settings: model.FileSettings{
    73  			DriverName:              model.NewString(model.IMAGE_DRIVER_S3),
    74  			AmazonS3AccessKeyId:     model.NewString(model.MINIO_ACCESS_KEY),
    75  			AmazonS3SecretAccessKey: model.NewString(model.MINIO_SECRET_KEY),
    76  			AmazonS3Bucket:          model.NewString(model.MINIO_BUCKET),
    77  			AmazonS3Region:          model.NewString(""),
    78  			AmazonS3Endpoint:        model.NewString(s3Endpoint),
    79  			AmazonS3PathPrefix:      model.NewString(""),
    80  			AmazonS3SSL:             model.NewBool(false),
    81  			AmazonS3SSE:             model.NewBool(encrypt),
    82  		},
    83  	})
    84  }
    85  
    86  func (s *FileBackendTestSuite) SetupTest() {
    87  	utils.TranslationsPreInit()
    88  
    89  	backend, err := NewFileBackend(&s.settings, true)
    90  	require.Nil(s.T(), err)
    91  	s.backend = backend
    92  }
    93  
    94  func (s *FileBackendTestSuite) TestConnection() {
    95  	s.Nil(s.backend.TestConnection())
    96  }
    97  
    98  func (s *FileBackendTestSuite) TestReadWriteFile() {
    99  	b := []byte("test")
   100  	path := "tests/" + model.NewId()
   101  
   102  	written, err := s.backend.WriteFile(bytes.NewReader(b), path)
   103  	s.Nil(err)
   104  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   105  	defer s.backend.RemoveFile(path)
   106  
   107  	read, err := s.backend.ReadFile(path)
   108  	s.Nil(err)
   109  
   110  	readString := string(read)
   111  	s.EqualValues(readString, "test")
   112  }
   113  
   114  func (s *FileBackendTestSuite) TestReadWriteFileImage() {
   115  	b := []byte("testimage")
   116  	path := "tests/" + model.NewId() + ".png"
   117  
   118  	written, err := s.backend.WriteFile(bytes.NewReader(b), path)
   119  	s.Nil(err)
   120  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   121  	defer s.backend.RemoveFile(path)
   122  
   123  	read, err := s.backend.ReadFile(path)
   124  	s.Nil(err)
   125  
   126  	readString := string(read)
   127  	s.EqualValues(readString, "testimage")
   128  }
   129  
   130  func (s *FileBackendTestSuite) TestFileExists() {
   131  	b := []byte("testimage")
   132  	path := "tests/" + model.NewId() + ".png"
   133  
   134  	_, err := s.backend.WriteFile(bytes.NewReader(b), path)
   135  	s.Nil(err)
   136  	defer s.backend.RemoveFile(path)
   137  
   138  	res, err := s.backend.FileExists(path)
   139  	s.Nil(err)
   140  	s.True(res)
   141  
   142  	res, err = s.backend.FileExists("tests/idontexist.png")
   143  	s.Nil(err)
   144  	s.False(res)
   145  }
   146  
   147  func (s *FileBackendTestSuite) TestCopyFile() {
   148  	b := []byte("test")
   149  	path1 := "tests/" + model.NewId()
   150  	path2 := "tests/" + model.NewId()
   151  
   152  	written, err := s.backend.WriteFile(bytes.NewReader(b), path1)
   153  	s.Nil(err)
   154  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   155  	defer s.backend.RemoveFile(path1)
   156  
   157  	err = s.backend.CopyFile(path1, path2)
   158  	s.Nil(err)
   159  	defer s.backend.RemoveFile(path2)
   160  
   161  	_, err = s.backend.ReadFile(path1)
   162  	s.Nil(err)
   163  
   164  	_, err = s.backend.ReadFile(path2)
   165  	s.Nil(err)
   166  }
   167  
   168  func (s *FileBackendTestSuite) TestCopyFileToDirectoryThatDoesntExist() {
   169  	b := []byte("test")
   170  	path1 := "tests/" + model.NewId()
   171  	path2 := "tests/newdirectory/" + model.NewId()
   172  
   173  	written, err := s.backend.WriteFile(bytes.NewReader(b), path1)
   174  	s.Nil(err)
   175  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   176  	defer s.backend.RemoveFile(path1)
   177  
   178  	err = s.backend.CopyFile(path1, path2)
   179  	s.Nil(err)
   180  	defer s.backend.RemoveFile(path2)
   181  
   182  	_, err = s.backend.ReadFile(path1)
   183  	s.Nil(err)
   184  
   185  	_, err = s.backend.ReadFile(path2)
   186  	s.Nil(err)
   187  }
   188  
   189  func (s *FileBackendTestSuite) TestMoveFile() {
   190  	b := []byte("test")
   191  	path1 := "tests/" + model.NewId()
   192  	path2 := "tests/" + model.NewId()
   193  
   194  	written, err := s.backend.WriteFile(bytes.NewReader(b), path1)
   195  	s.Nil(err)
   196  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   197  	defer s.backend.RemoveFile(path1)
   198  
   199  	s.Nil(s.backend.MoveFile(path1, path2))
   200  	defer s.backend.RemoveFile(path2)
   201  
   202  	_, err = s.backend.ReadFile(path1)
   203  	s.Error(err)
   204  
   205  	_, err = s.backend.ReadFile(path2)
   206  	s.Nil(err)
   207  }
   208  
   209  func (s *FileBackendTestSuite) TestRemoveFile() {
   210  	b := []byte("test")
   211  	path := "tests/" + model.NewId()
   212  
   213  	written, err := s.backend.WriteFile(bytes.NewReader(b), path)
   214  	s.Nil(err)
   215  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   216  	s.Nil(s.backend.RemoveFile(path))
   217  
   218  	_, err = s.backend.ReadFile(path)
   219  	s.Error(err)
   220  
   221  	written, err = s.backend.WriteFile(bytes.NewReader(b), "tests2/foo")
   222  	s.Nil(err)
   223  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   224  
   225  	written, err = s.backend.WriteFile(bytes.NewReader(b), "tests2/bar")
   226  	s.Nil(err)
   227  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   228  
   229  	written, err = s.backend.WriteFile(bytes.NewReader(b), "tests2/asdf")
   230  	s.Nil(err)
   231  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   232  
   233  	s.Nil(s.backend.RemoveDirectory("tests2"))
   234  }
   235  
   236  func (s *FileBackendTestSuite) TestListDirectory() {
   237  	b := []byte("test")
   238  	path1 := "19700101/" + model.NewId()
   239  	path2 := "19800101/" + model.NewId()
   240  
   241  	paths, err := s.backend.ListDirectory("19700101")
   242  	s.Nil(err)
   243  	s.Len(*paths, 0)
   244  
   245  	written, err := s.backend.WriteFile(bytes.NewReader(b), path1)
   246  	s.Nil(err)
   247  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   248  
   249  	written, err = s.backend.WriteFile(bytes.NewReader(b), path2)
   250  	s.Nil(err)
   251  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   252  
   253  	paths, err = s.backend.ListDirectory("19700101")
   254  	s.Nil(err)
   255  	s.Len(*paths, 1)
   256  	s.Equal(path1, (*paths)[0])
   257  
   258  	paths, err = s.backend.ListDirectory("19700101/")
   259  	s.Nil(err)
   260  	s.Len(*paths, 1)
   261  	s.Equal(path1, (*paths)[0])
   262  
   263  	paths, err = s.backend.ListDirectory("")
   264  	s.Nil(err)
   265  
   266  	found1 := false
   267  	found2 := false
   268  	for _, path := range *paths {
   269  		if path == "19700101" {
   270  			found1 = true
   271  		} else if path == "19800101" {
   272  			found2 = true
   273  		}
   274  	}
   275  	s.True(found1)
   276  	s.True(found2)
   277  
   278  	s.backend.RemoveFile(path1)
   279  	s.backend.RemoveFile(path2)
   280  }
   281  
   282  func (s *FileBackendTestSuite) TestRemoveDirectory() {
   283  	b := []byte("test")
   284  
   285  	written, err := s.backend.WriteFile(bytes.NewReader(b), "tests2/foo")
   286  	s.Nil(err)
   287  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   288  
   289  	written, err = s.backend.WriteFile(bytes.NewReader(b), "tests2/bar")
   290  	s.Nil(err)
   291  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   292  
   293  	written, err = s.backend.WriteFile(bytes.NewReader(b), "tests2/aaa")
   294  	s.Nil(err)
   295  	s.EqualValues(len(b), written, "expected given number of bytes to have been written")
   296  
   297  	s.Nil(s.backend.RemoveDirectory("tests2"))
   298  
   299  	_, err = s.backend.ReadFile("tests2/foo")
   300  	s.Error(err)
   301  	_, err = s.backend.ReadFile("tests2/bar")
   302  	s.Error(err)
   303  	_, err = s.backend.ReadFile("tests2/asdf")
   304  	s.Error(err)
   305  }