github.com/xzl8028/xenia-server@v0.0.0-20190809101854-18450a97da63/store/storetest/file_info_store.go (about)

     1  // Copyright (c) 2016-present Xenia, Inc. All Rights Reserved.
     2  // See License.txt for license information.
     3  
     4  package storetest
     5  
     6  import (
     7  	"fmt"
     8  	"testing"
     9  
    10  	"github.com/xzl8028/xenia-server/model"
    11  	"github.com/xzl8028/xenia-server/store"
    12  
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func TestFileInfoStore(t *testing.T, ss store.Store) {
    18  	t.Run("FileInfoSaveGet", func(t *testing.T) { testFileInfoSaveGet(t, ss) })
    19  	t.Run("FileInfoSaveGetByPath", func(t *testing.T) { testFileInfoSaveGetByPath(t, ss) })
    20  	t.Run("FileInfoGetForPost", func(t *testing.T) { testFileInfoGetForPost(t, ss) })
    21  	t.Run("FileInfoGetForUser", func(t *testing.T) { testFileInfoGetForUser(t, ss) })
    22  	t.Run("FileInfoAttachToPost", func(t *testing.T) { testFileInfoAttachToPost(t, ss) })
    23  	t.Run("FileInfoDeleteForPost", func(t *testing.T) { testFileInfoDeleteForPost(t, ss) })
    24  	t.Run("FileInfoPermanentDelete", func(t *testing.T) { testFileInfoPermanentDelete(t, ss) })
    25  	t.Run("FileInfoPermanentDeleteBatch", func(t *testing.T) { testFileInfoPermanentDeleteBatch(t, ss) })
    26  	t.Run("FileInfoPermanentDeleteByUser", func(t *testing.T) { testFileInfoPermanentDeleteByUser(t, ss) })
    27  }
    28  
    29  func testFileInfoSaveGet(t *testing.T, ss store.Store) {
    30  	info := &model.FileInfo{
    31  		CreatorId: model.NewId(),
    32  		Path:      "file.txt",
    33  	}
    34  
    35  	info, err := ss.FileInfo().Save(info)
    36  	require.Nil(t, err)
    37  	require.NotEqual(t, len(info.Id), 0)
    38  
    39  	defer func() {
    40  		ss.FileInfo().PermanentDelete(info.Id)
    41  	}()
    42  
    43  	rinfo, err := ss.FileInfo().Get(info.Id)
    44  	require.Nil(t, err)
    45  	require.Equal(t, info.Id, rinfo.Id)
    46  
    47  	info2, err := ss.FileInfo().Save(&model.FileInfo{
    48  		CreatorId: model.NewId(),
    49  		Path:      "file.txt",
    50  		DeleteAt:  123,
    51  	})
    52  	require.Nil(t, err)
    53  
    54  	_, err = ss.FileInfo().Get(info2.Id)
    55  	assert.NotNil(t, err)
    56  
    57  	defer func() {
    58  		ss.FileInfo().PermanentDelete(info2.Id)
    59  	}()
    60  }
    61  
    62  func testFileInfoSaveGetByPath(t *testing.T, ss store.Store) {
    63  	info := &model.FileInfo{
    64  		CreatorId: model.NewId(),
    65  		Path:      fmt.Sprintf("%v/file.txt", model.NewId()),
    66  	}
    67  
    68  	info, err := ss.FileInfo().Save(info)
    69  	require.Nil(t, err)
    70  	assert.NotEqual(t, len(info.Id), 0)
    71  	defer func() {
    72  		ss.FileInfo().PermanentDelete(info.Id)
    73  	}()
    74  
    75  	rinfo, err := ss.FileInfo().GetByPath(info.Path)
    76  	require.Nil(t, err)
    77  	assert.Equal(t, info.Id, rinfo.Id)
    78  
    79  	info2, err := ss.FileInfo().Save(&model.FileInfo{
    80  		CreatorId: model.NewId(),
    81  		Path:      "file.txt",
    82  		DeleteAt:  123,
    83  	})
    84  	require.Nil(t, err)
    85  
    86  	_, err = ss.FileInfo().GetByPath(info2.Id)
    87  	assert.NotNil(t, err)
    88  
    89  	defer func() {
    90  		ss.FileInfo().PermanentDelete(info2.Id)
    91  	}()
    92  }
    93  
    94  func testFileInfoGetForPost(t *testing.T, ss store.Store) {
    95  	userId := model.NewId()
    96  	postId := model.NewId()
    97  
    98  	infos := []*model.FileInfo{
    99  		{
   100  			PostId:    postId,
   101  			CreatorId: userId,
   102  			Path:      "file.txt",
   103  		},
   104  		{
   105  			PostId:    postId,
   106  			CreatorId: userId,
   107  			Path:      "file.txt",
   108  		},
   109  		{
   110  			PostId:    postId,
   111  			CreatorId: userId,
   112  			Path:      "file.txt",
   113  			DeleteAt:  123,
   114  		},
   115  		{
   116  			PostId:    model.NewId(),
   117  			CreatorId: userId,
   118  			Path:      "file.txt",
   119  		},
   120  	}
   121  
   122  	for i, info := range infos {
   123  		newInfo, err := ss.FileInfo().Save(info)
   124  		require.Nil(t, err)
   125  		infos[i] = newInfo
   126  		defer func(id string) {
   127  			ss.FileInfo().PermanentDelete(id)
   128  		}(newInfo.Id)
   129  	}
   130  
   131  	postInfos, err := ss.FileInfo().GetForPost(postId, true, false)
   132  	require.Nil(t, err)
   133  	assert.Len(t, postInfos, 2)
   134  
   135  	postInfos, err = ss.FileInfo().GetForPost(postId, false, false)
   136  	require.Nil(t, err)
   137  	assert.Len(t, postInfos, 2)
   138  
   139  	postInfos, err = ss.FileInfo().GetForPost(postId, true, true)
   140  	require.Nil(t, err)
   141  	assert.Len(t, postInfos, 2)
   142  }
   143  
   144  func testFileInfoGetForUser(t *testing.T, ss store.Store) {
   145  	userId := model.NewId()
   146  	userId2 := model.NewId()
   147  	postId := model.NewId()
   148  
   149  	infos := []*model.FileInfo{
   150  		{
   151  			PostId:    postId,
   152  			CreatorId: userId,
   153  			Path:      "file.txt",
   154  		},
   155  		{
   156  			PostId:    postId,
   157  			CreatorId: userId,
   158  			Path:      "file.txt",
   159  		},
   160  		{
   161  			PostId:    postId,
   162  			CreatorId: userId,
   163  			Path:      "file.txt",
   164  		},
   165  		{
   166  			PostId:    model.NewId(),
   167  			CreatorId: userId2,
   168  			Path:      "file.txt",
   169  		},
   170  	}
   171  
   172  	for i, info := range infos {
   173  		newInfo, err := ss.FileInfo().Save(info)
   174  		require.Nil(t, err)
   175  		infos[i] = newInfo
   176  		defer func(id string) {
   177  			ss.FileInfo().PermanentDelete(id)
   178  		}(newInfo.Id)
   179  	}
   180  
   181  	userPosts, err := ss.FileInfo().GetForUser(userId)
   182  	require.Nil(t, err)
   183  	assert.Len(t, userPosts, 3)
   184  
   185  	userPosts, err = ss.FileInfo().GetForUser(userId2)
   186  	require.Nil(t, err)
   187  	assert.Len(t, userPosts, 1)
   188  }
   189  
   190  func testFileInfoAttachToPost(t *testing.T, ss store.Store) {
   191  	t.Run("should attach files", func(t *testing.T) {
   192  		userId := model.NewId()
   193  		postId := model.NewId()
   194  
   195  		info1, err := ss.FileInfo().Save(&model.FileInfo{
   196  			CreatorId: userId,
   197  			Path:      "file.txt",
   198  		})
   199  		require.Nil(t, err)
   200  		info2, err := ss.FileInfo().Save(&model.FileInfo{
   201  			CreatorId: userId,
   202  			Path:      "file2.txt",
   203  		})
   204  		require.Nil(t, err)
   205  
   206  		require.Equal(t, "", info1.PostId)
   207  		require.Equal(t, "", info2.PostId)
   208  
   209  		err = ss.FileInfo().AttachToPost(info1.Id, postId, userId)
   210  		assert.Nil(t, err)
   211  
   212  		err = ss.FileInfo().AttachToPost(info2.Id, postId, userId)
   213  		assert.Nil(t, err)
   214  
   215  		data, err := ss.FileInfo().GetForPost(postId, true, false)
   216  		assert.Nil(t, err)
   217  
   218  		assert.Len(t, data, 2)
   219  		assert.True(t, data[0].Id == info1.Id || data[0].Id == info2.Id)
   220  		assert.True(t, data[1].Id == info1.Id || data[1].Id == info2.Id)
   221  	})
   222  
   223  	t.Run("should not attach files to multiple posts", func(t *testing.T) {
   224  		userId := model.NewId()
   225  		postId := model.NewId()
   226  
   227  		info, err := ss.FileInfo().Save(&model.FileInfo{
   228  			CreatorId: userId,
   229  			Path:      "file.txt",
   230  		})
   231  		require.Nil(t, err)
   232  
   233  		require.Equal(t, "", info.PostId)
   234  
   235  		err = ss.FileInfo().AttachToPost(info.Id, model.NewId(), userId)
   236  		assert.Nil(t, err)
   237  
   238  		err = ss.FileInfo().AttachToPost(info.Id, postId, userId)
   239  		assert.NotNil(t, err)
   240  	})
   241  
   242  	t.Run("should not attach files owned from a different user", func(t *testing.T) {
   243  		userId := model.NewId()
   244  		postId := model.NewId()
   245  
   246  		info, err := ss.FileInfo().Save(&model.FileInfo{
   247  			CreatorId: model.NewId(),
   248  			Path:      "file.txt",
   249  		})
   250  		require.Nil(t, err)
   251  
   252  		require.Equal(t, "", info.PostId)
   253  
   254  		err = ss.FileInfo().AttachToPost(info.Id, postId, userId)
   255  		assert.NotNil(t, err)
   256  	})
   257  }
   258  
   259  func testFileInfoDeleteForPost(t *testing.T, ss store.Store) {
   260  	userId := model.NewId()
   261  	postId := model.NewId()
   262  
   263  	infos := []*model.FileInfo{
   264  		{
   265  			PostId:    postId,
   266  			CreatorId: userId,
   267  			Path:      "file.txt",
   268  		},
   269  		{
   270  			PostId:    postId,
   271  			CreatorId: userId,
   272  			Path:      "file.txt",
   273  		},
   274  		{
   275  			PostId:    postId,
   276  			CreatorId: userId,
   277  			Path:      "file.txt",
   278  			DeleteAt:  123,
   279  		},
   280  		{
   281  			PostId:    model.NewId(),
   282  			CreatorId: userId,
   283  			Path:      "file.txt",
   284  		},
   285  	}
   286  
   287  	for i, info := range infos {
   288  		newInfo, err := ss.FileInfo().Save(info)
   289  		require.Nil(t, err)
   290  		infos[i] = newInfo
   291  		defer func(id string) {
   292  			ss.FileInfo().PermanentDelete(id)
   293  		}(newInfo.Id)
   294  	}
   295  
   296  	_, err := ss.FileInfo().DeleteForPost(postId)
   297  	require.Nil(t, err)
   298  
   299  	infos, err = ss.FileInfo().GetForPost(postId, true, false)
   300  	require.Nil(t, err)
   301  	assert.Len(t, infos, 0)
   302  }
   303  
   304  func testFileInfoPermanentDelete(t *testing.T, ss store.Store) {
   305  	info, err := ss.FileInfo().Save(&model.FileInfo{
   306  		PostId:    model.NewId(),
   307  		CreatorId: model.NewId(),
   308  		Path:      "file.txt",
   309  	})
   310  	require.Nil(t, err)
   311  
   312  	err = ss.FileInfo().PermanentDelete(info.Id)
   313  	require.Nil(t, err)
   314  }
   315  
   316  func testFileInfoPermanentDeleteBatch(t *testing.T, ss store.Store) {
   317  	postId := model.NewId()
   318  
   319  	_, err := ss.FileInfo().Save(&model.FileInfo{
   320  		PostId:    postId,
   321  		CreatorId: model.NewId(),
   322  		Path:      "file.txt",
   323  		CreateAt:  1000,
   324  	})
   325  	require.Nil(t, err)
   326  
   327  	_, err = ss.FileInfo().Save(&model.FileInfo{
   328  		PostId:    postId,
   329  		CreatorId: model.NewId(),
   330  		Path:      "file.txt",
   331  		CreateAt:  1200,
   332  	})
   333  	require.Nil(t, err)
   334  
   335  	_, err = ss.FileInfo().Save(&model.FileInfo{
   336  		PostId:    postId,
   337  		CreatorId: model.NewId(),
   338  		Path:      "file.txt",
   339  		CreateAt:  2000,
   340  	})
   341  	require.Nil(t, err)
   342  
   343  	postFiles, err := ss.FileInfo().GetForPost(postId, true, false)
   344  	require.Nil(t, err)
   345  	assert.Len(t, postFiles, 3)
   346  
   347  	_, err = ss.FileInfo().PermanentDeleteBatch(1500, 1000)
   348  	require.Nil(t, err)
   349  
   350  	postFiles, err = ss.FileInfo().GetForPost(postId, true, false)
   351  	require.Nil(t, err)
   352  	assert.Len(t, postFiles, 1)
   353  }
   354  
   355  func testFileInfoPermanentDeleteByUser(t *testing.T, ss store.Store) {
   356  	userId := model.NewId()
   357  	postId := model.NewId()
   358  
   359  	_, err := ss.FileInfo().Save(&model.FileInfo{
   360  		PostId:    postId,
   361  		CreatorId: userId,
   362  		Path:      "file.txt",
   363  	})
   364  	require.Nil(t, err)
   365  
   366  	_, err = ss.FileInfo().PermanentDeleteByUser(userId)
   367  	require.Nil(t, err)
   368  }