mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-14 03:06:39 +00:00
23fc70f4e6
* add support for extracting Updated field from Statusable implementers
* add support for status edits in the database, and update status dereferencer to handle them
* remove unused AdditionalInfo{}.CreatedAt
* remove unused AdditionalEmojiInfo{}.CreatedAt
* update new mention creation to use status.UpdatedAt
* remove mention.UpdatedAt, fixes related to NewULIDFromTime() change
* add migration to remove Mention{}.UpdatedAt field
* add migration to add the StatusEdit{} table
* start adding tests, add delete function for status edits
* add more of status edit migrations, fill in more of the necessary edit delete functionality
* remove unused function
* allow generating gotosocial compatible ulid via CLI with `go run ./cmd/gen-ulid`
* add StatusEdit{} test models
* fix new statusedits sql
* use model instead of table name
* actually remove the Mention.UpdatedAt field...
* fix tests now new models are added, add more status edit DB tests
* fix panic wording
* add test for deleting status edits
* don't automatically set `updated_at` field on updated statuses
* flesh out more of the dereferencer status edit tests, ensure updated at field set on outgoing AS statuses
* remove media_attachments.updated_at column
* fix up more tests, further complete the dereferencer status edit tests
* update more status serialization tests not expecting 'updated' AS property
* gah!! json serialization tests!!
* undo some gtscontext wrapping changes
* more serialization test fixing 🥲
* more test fixing, ensure the edit.status_id field is actually set 🤦
* fix status edit test
* grrr linter
* add edited_at field to apimodel status
* remove the choice of paging on the timeline public filtered test (otherwise it needs updating every time you add statuses ...)
* ensure that status.updated_at always fits chronologically
* fix more serialization tests ...
* add more code comments
* fix envparsing
* update swagger file
* properly handle media description changes during status edits
* slight formatting tweak
* code comment
1018 lines
32 KiB
Go
1018 lines
32 KiB
Go
// GoToSocial
|
|
// Copyright (C) GoToSocial Authors admin@gotosocial.org
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package media_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/md5"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"codeberg.org/gruf/go-iotools"
|
|
"codeberg.org/gruf/go-storage/disk"
|
|
"github.com/stretchr/testify/suite"
|
|
gtsmodel "github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
|
|
"github.com/superseriousbusiness/gotosocial/internal/media"
|
|
"github.com/superseriousbusiness/gotosocial/internal/state"
|
|
"github.com/superseriousbusiness/gotosocial/internal/storage"
|
|
gtsstorage "github.com/superseriousbusiness/gotosocial/internal/storage"
|
|
"github.com/superseriousbusiness/gotosocial/internal/util"
|
|
"github.com/superseriousbusiness/gotosocial/testrig"
|
|
)
|
|
|
|
type ManagerTestSuite struct {
|
|
MediaStandardTestSuite
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestEmojiProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/rainbow-original.png")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
processing, err := suite.manager.CreateEmoji(ctx,
|
|
"rainbow_test",
|
|
"",
|
|
data,
|
|
media.AdditionalEmojiInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
|
|
// do a blocking call to fetch the emoji
|
|
emoji, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(emoji)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.Equal("image/apng", emoji.ImageContentType)
|
|
suite.Equal("image/png", emoji.ImageStaticContentType)
|
|
suite.Equal(36702, emoji.ImageFileSize)
|
|
|
|
// now make sure the emoji is in the database
|
|
dbEmoji, err := suite.db.GetEmojiByID(ctx, emoji.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbEmoji)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbEmoji.ImagePath, "./test/rainbow-original.png")
|
|
equalFiles(suite.T(), suite.state.Storage, dbEmoji.ImageStaticPath, "./test/rainbow-static.png")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestEmojiProcessRefresh() {
|
|
ctx := context.Background()
|
|
|
|
// we're going to 'refresh' the remote 'yell' emoji by changing the image url to the pixellated gts logo
|
|
originalEmoji := suite.testEmojis["yell"]
|
|
|
|
emojiToUpdate, err := suite.db.GetEmojiByID(ctx, originalEmoji.ID)
|
|
suite.NoError(err)
|
|
|
|
newImageRemoteURL := "http://fossbros-anonymous.io/some/image/path.png"
|
|
|
|
oldEmojiImagePath := emojiToUpdate.ImagePath
|
|
oldEmojiImageStaticPath := emojiToUpdate.ImageStaticPath
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
b, err := os.ReadFile("./test/gts_pixellated-original.png")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
processing, err := suite.manager.UpdateEmoji(ctx,
|
|
emojiToUpdate,
|
|
data,
|
|
media.AdditionalEmojiInfo{
|
|
Domain: &emojiToUpdate.Domain,
|
|
ImageRemoteURL: &newImageRemoteURL,
|
|
},
|
|
)
|
|
suite.NoError(err)
|
|
|
|
// do a blocking call to fetch the emoji
|
|
emoji, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(emoji)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
suite.Equal(originalEmoji.ID, emoji.ID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.Equal("image/png", emoji.ImageContentType)
|
|
suite.Equal("image/png", emoji.ImageStaticContentType)
|
|
suite.Equal(10296, emoji.ImageFileSize)
|
|
|
|
// now make sure the emoji is in the database
|
|
dbEmoji, err := suite.db.GetEmojiByID(ctx, emoji.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbEmoji)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbEmoji.ImagePath, "./test/gts_pixellated-original.png")
|
|
equalFiles(suite.T(), suite.state.Storage, dbEmoji.ImageStaticPath, "./test/gts_pixellated-static.png")
|
|
|
|
// most fields should be different on the emoji now from what they were before
|
|
suite.Equal(originalEmoji.ID, dbEmoji.ID)
|
|
suite.NotEqual(originalEmoji.ImageRemoteURL, dbEmoji.ImageRemoteURL)
|
|
suite.NotEqual(originalEmoji.ImageURL, dbEmoji.ImageURL)
|
|
suite.NotEqual(originalEmoji.ImageStaticURL, dbEmoji.ImageStaticURL)
|
|
suite.NotEqual(originalEmoji.ImageFileSize, dbEmoji.ImageFileSize)
|
|
suite.NotEqual(originalEmoji.ImageStaticFileSize, dbEmoji.ImageStaticFileSize)
|
|
suite.NotEqual(originalEmoji.ImagePath, dbEmoji.ImagePath)
|
|
suite.NotEqual(originalEmoji.ImageStaticPath, dbEmoji.ImageStaticPath)
|
|
suite.NotEqual(originalEmoji.ImageStaticPath, dbEmoji.ImageStaticPath)
|
|
suite.NotEqual(originalEmoji.UpdatedAt, dbEmoji.UpdatedAt)
|
|
|
|
// the old image files should no longer be in storage
|
|
_, err = suite.storage.Get(ctx, oldEmojiImagePath)
|
|
suite.True(storage.IsNotFound(err))
|
|
_, err = suite.storage.Get(ctx, oldEmojiImageStaticPath)
|
|
suite.True(storage.IsNotFound(err))
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestEmojiProcessTooLarge() {
|
|
ctx := context.Background()
|
|
|
|
// Open test image as file for reading.
|
|
file, err := os.Open("./test/big-panda.gif")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Get file size info.
|
|
stat, err := file.Stat()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Set max allowed size UNDER image size.
|
|
lr := io.LimitReader(file, stat.Size()-10)
|
|
rc := iotools.ReadCloser(lr, file)
|
|
|
|
processing, err := suite.manager.CreateEmoji(ctx,
|
|
"big_panda",
|
|
"",
|
|
func(ctx context.Context) (reader io.ReadCloser, err error) {
|
|
return rc, nil
|
|
},
|
|
media.AdditionalEmojiInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
|
|
// do a blocking call to fetch the emoji
|
|
_, err = processing.Load(ctx)
|
|
suite.EqualError(err, "store: error draining data to tmp: reached read limit 630kiB")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestEmojiWebpProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/nb-flag-original.webp")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateEmoji(ctx,
|
|
"nb-flag",
|
|
"",
|
|
data,
|
|
media.AdditionalEmojiInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
|
|
// do a blocking call to fetch the emoji
|
|
emoji, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(emoji)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.Equal("image/webp", emoji.ImageContentType)
|
|
suite.Equal("image/png", emoji.ImageStaticContentType)
|
|
suite.Equal(294, emoji.ImageFileSize)
|
|
|
|
// now make sure the emoji is in the database
|
|
dbEmoji, err := suite.db.GetEmojiByID(ctx, emoji.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbEmoji)
|
|
|
|
// ensure files are equal
|
|
equalFiles(suite.T(), suite.state.Storage, dbEmoji.ImagePath, "./test/nb-flag-original.webp")
|
|
equalFiles(suite.T(), suite.state.Storage, dbEmoji.ImageStaticPath, "./test/nb-flag-static.png")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestSimpleJpegProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/test-jpeg.jpg")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.EqualValues(gtsmodel.Original{
|
|
Width: 1920, Height: 1080, Size: 2073600, Aspect: 1.7777777777777777,
|
|
}, attachment.FileMeta.Original)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 512, Height: 288, Size: 147456, Aspect: 1.7777777777777777,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("image/jpeg", attachment.File.ContentType)
|
|
suite.Equal("image/jpeg", attachment.Thumbnail.ContentType)
|
|
suite.Equal(269739, attachment.File.FileSize)
|
|
suite.Equal(22858, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LiB|W-#6RQR.~qvzRjWF_3rqV@a$", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/test-jpeg-processed.jpg")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/test-jpeg-thumbnail.jpeg")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestSimpleJpegProcessTooLarge() {
|
|
ctx := context.Background()
|
|
|
|
// Open test image as file for reading.
|
|
file, err := os.Open("./test/test-jpeg.jpg")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Get file size info.
|
|
stat, err := file.Stat()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Set max allowed size UNDER image size.
|
|
lr := io.LimitReader(file, stat.Size()-10)
|
|
rc := iotools.ReadCloser(lr, file)
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
func(ctx context.Context) (reader io.ReadCloser, err error) {
|
|
return rc, nil
|
|
},
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
_, err = processing.Load(ctx)
|
|
suite.EqualError(err, "store: error draining data to tmp: reached read limit 263kiB")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestPDFProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from Frantz
|
|
b, err := os.ReadFile("./test/Frantz-Fanon-The-Wretched-of-the-Earth-1965.pdf")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
suite.Zero(attachment.FileMeta)
|
|
suite.Zero(attachment.File.ContentType)
|
|
suite.Zero(attachment.Thumbnail.ContentType)
|
|
suite.Zero(attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// Attachment should have type unknown
|
|
suite.Equal(gtsmodel.FileTypeUnknown, dbAttachment.Type)
|
|
|
|
// Nothing should be in storage for this attachment.
|
|
stored, err := suite.storage.Has(ctx, attachment.File.Path)
|
|
suite.NoError(err)
|
|
suite.False(stored)
|
|
stored, err = suite.storage.Has(ctx, attachment.Thumbnail.Path)
|
|
suite.NoError(err)
|
|
suite.False(stored)
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestSlothVineProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test video
|
|
b, err := os.ReadFile("./test/test-mp4-original.mp4")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the video
|
|
suite.Equal(338, attachment.FileMeta.Original.Width)
|
|
suite.Equal(240, attachment.FileMeta.Original.Height)
|
|
suite.Equal(81120, attachment.FileMeta.Original.Size)
|
|
suite.EqualValues(float32(1.4083333), attachment.FileMeta.Original.Aspect)
|
|
suite.EqualValues(float32(6.641), *attachment.FileMeta.Original.Duration)
|
|
suite.EqualValues(float32(29), *attachment.FileMeta.Original.Framerate)
|
|
suite.EqualValues(0x5be18, *attachment.FileMeta.Original.Bitrate)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 338, Height: 240, Size: 81120, Aspect: 1.4083333333333334,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("video/mp4", attachment.File.ContentType)
|
|
suite.Equal("image/webp", attachment.Thumbnail.ContentType)
|
|
suite.Equal(312453, attachment.File.FileSize)
|
|
suite.Equal(5598, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LgIYH}xtNsofxtfPW.j[_4axn+of", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/test-mp4-processed.mp4")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/test-mp4-thumbnail.webp")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestAnimatedGifProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/clock-original.gif")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.EqualValues(gtsmodel.Original{
|
|
Width: 528,
|
|
Height: 528,
|
|
Size: 278784,
|
|
Aspect: 1,
|
|
Duration: util.Ptr(float32(8.58)),
|
|
Framerate: util.Ptr(float32(16)),
|
|
Bitrate: util.Ptr(uint64(114092)),
|
|
}, attachment.FileMeta.Original)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 512,
|
|
Height: 512,
|
|
Size: 262144,
|
|
Aspect: 1,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("image/gif", attachment.File.ContentType)
|
|
suite.Equal("image/webp", attachment.Thumbnail.ContentType)
|
|
suite.Equal(122364, attachment.File.FileSize)
|
|
suite.Equal(12962, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LmKUZkt700ofoffQofj[00WBj[WB", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/clock-processed.gif")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/clock-thumbnail.webp")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestLongerMp4Process() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test video
|
|
b, err := os.ReadFile("./test/longer-mp4-original.mp4")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the video
|
|
suite.Equal(600, attachment.FileMeta.Original.Width)
|
|
suite.Equal(330, attachment.FileMeta.Original.Height)
|
|
suite.Equal(198000, attachment.FileMeta.Original.Size)
|
|
suite.EqualValues(float32(1.8181819), attachment.FileMeta.Original.Aspect)
|
|
suite.EqualValues(float32(16.6), *attachment.FileMeta.Original.Duration)
|
|
suite.EqualValues(float32(10), *attachment.FileMeta.Original.Framerate)
|
|
suite.EqualValues(0xce3a, *attachment.FileMeta.Original.Bitrate)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 512, Height: 281, Size: 143872, Aspect: 1.8181819,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("video/mp4", attachment.File.ContentType)
|
|
suite.Equal("image/webp", attachment.Thumbnail.ContentType)
|
|
suite.Equal(109569, attachment.File.FileSize)
|
|
suite.Equal(2958, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LIQ9}}_3IU?b~qM{ofayWBWVofRj", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/longer-mp4-processed.mp4")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/longer-mp4-thumbnail.webp")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestBirdnestMp4Process() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test video
|
|
b, err := os.ReadFile("./test/birdnest-original.mp4")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the video
|
|
suite.Equal(404, attachment.FileMeta.Original.Width)
|
|
suite.Equal(720, attachment.FileMeta.Original.Height)
|
|
suite.Equal(290880, attachment.FileMeta.Original.Size)
|
|
suite.EqualValues(float32(0.5611111), attachment.FileMeta.Original.Aspect)
|
|
suite.EqualValues(float32(9.823), *attachment.FileMeta.Original.Duration)
|
|
suite.EqualValues(float32(30), *attachment.FileMeta.Original.Framerate)
|
|
suite.EqualValues(0x11844c, *attachment.FileMeta.Original.Bitrate)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 287, Height: 512, Size: 146944, Aspect: 0.5611111,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("video/mp4", attachment.File.ContentType)
|
|
suite.Equal("image/webp", attachment.Thumbnail.ContentType)
|
|
suite.Equal(1409625, attachment.File.FileSize)
|
|
suite.Equal(15056, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LLF$nqafRO.9DgM_RPadtkV@WCMx", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/birdnest-processed.mp4")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/birdnest-thumbnail.webp")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestOpusProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/test-opus-original.opus")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.EqualValues(gtsmodel.Original{
|
|
Duration: util.Ptr(float32(122.10006)),
|
|
Bitrate: util.Ptr(uint64(116426)),
|
|
}, attachment.FileMeta.Original)
|
|
suite.Equal("audio/opus", attachment.File.ContentType)
|
|
suite.Equal(1776956, attachment.File.FileSize)
|
|
suite.Empty(attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/test-opus-processed.opus")
|
|
suite.Zero(dbAttachment.Thumbnail.FileSize)
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestPngNoAlphaChannelProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/test-png-noalphachannel.png")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.EqualValues(gtsmodel.Original{
|
|
Width: 186, Height: 187, Size: 34782, Aspect: 0.9946524064171123,
|
|
}, attachment.FileMeta.Original)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 186, Height: 187, Size: 34782, Aspect: 0.9946524064171123,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("image/png", attachment.File.ContentType)
|
|
suite.Equal("image/jpeg", attachment.Thumbnail.ContentType)
|
|
suite.Equal(17471, attachment.File.FileSize)
|
|
suite.Equal(6446, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LGP%YL.A-?tA.9o#RURQ~ojp^~xW", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/test-png-noalphachannel-processed.png")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/test-png-noalphachannel-thumbnail.jpeg")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestPngAlphaChannelProcess() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/test-png-alphachannel.png")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.EqualValues(gtsmodel.Original{
|
|
Width: 186, Height: 187, Size: 34782, Aspect: 0.9946524064171123,
|
|
}, attachment.FileMeta.Original)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 186, Height: 187, Size: 34782, Aspect: 0.9946524064171123,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("image/png", attachment.File.ContentType)
|
|
suite.Equal("image/webp", attachment.Thumbnail.ContentType)
|
|
suite.Equal(18832, attachment.File.FileSize)
|
|
suite.Equal(3592, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LCN^lE.A-?xd?co#N1RQ~ojp~SxW", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/test-png-alphachannel-processed.png")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/test-png-alphachannel-thumbnail.jpeg")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestSimpleJpegProcessWithCallback() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/test-jpeg.jpg")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.EqualValues(gtsmodel.Original{
|
|
Width: 1920, Height: 1080, Size: 2073600, Aspect: 1.7777777777777777,
|
|
}, attachment.FileMeta.Original)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 512, Height: 288, Size: 147456, Aspect: 1.7777777777777777,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("image/jpeg", attachment.File.ContentType)
|
|
suite.Equal("image/jpeg", attachment.Thumbnail.ContentType)
|
|
suite.Equal(269739, attachment.File.FileSize)
|
|
suite.Equal(22858, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LiB|W-#6RQR.~qvzRjWF_3rqV@a$", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.File.Path, "./test/test-jpeg-processed.jpg")
|
|
equalFiles(suite.T(), suite.state.Storage, dbAttachment.Thumbnail.Path, "./test/test-jpeg-thumbnail.jpeg")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestSimpleJpegProcessWithDiskStorage() {
|
|
ctx := context.Background()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile("./test/test-jpeg.jpg")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
temp := fmt.Sprintf("./%s/gotosocial-test", os.TempDir())
|
|
defer os.RemoveAll(temp)
|
|
|
|
disk, err := disk.Open(temp, nil)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
var state state.State
|
|
|
|
testrig.StartNoopWorkers(&state)
|
|
defer testrig.StopWorkers(&state)
|
|
|
|
storage := >sstorage.Driver{
|
|
Storage: disk,
|
|
}
|
|
state.Storage = storage
|
|
state.DB = suite.db
|
|
|
|
diskManager := media.NewManager(&state)
|
|
suite.manager = diskManager
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// do a blocking call to fetch the attachment
|
|
attachment, err := processing.Load(ctx)
|
|
suite.NoError(err)
|
|
suite.NotNil(attachment)
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
// file meta should be correctly derived from the image
|
|
suite.EqualValues(gtsmodel.Original{
|
|
Width: 1920, Height: 1080, Size: 2073600, Aspect: 1.7777777777777777,
|
|
}, attachment.FileMeta.Original)
|
|
suite.EqualValues(gtsmodel.Small{
|
|
Width: 512, Height: 288, Size: 147456, Aspect: 1.7777777777777777,
|
|
}, attachment.FileMeta.Small)
|
|
suite.Equal("image/jpeg", attachment.File.ContentType)
|
|
suite.Equal("image/jpeg", attachment.Thumbnail.ContentType)
|
|
suite.Equal(269739, attachment.File.FileSize)
|
|
suite.Equal(22858, attachment.Thumbnail.FileSize)
|
|
suite.Equal("LiB|W-#6RQR.~qvzRjWF_3rqV@a$", attachment.Blurhash)
|
|
|
|
// now make sure the attachment is in the database
|
|
dbAttachment, err := suite.db.GetAttachmentByID(ctx, attachment.ID)
|
|
suite.NoError(err)
|
|
suite.NotNil(dbAttachment)
|
|
|
|
// ensure the files contain the expected data.
|
|
equalFiles(suite.T(), storage, dbAttachment.File.Path, "./test/test-jpeg-processed.jpg")
|
|
equalFiles(suite.T(), storage, dbAttachment.Thumbnail.Path, "./test/test-jpeg-thumbnail.jpeg")
|
|
}
|
|
|
|
func (suite *ManagerTestSuite) TestSmallSizedMediaTypeDetection_issue2263() {
|
|
for index, test := range []struct {
|
|
name string // Test title
|
|
path string // File path
|
|
expected string // Expected ContentType
|
|
}{
|
|
{
|
|
name: "big size JPEG",
|
|
path: "./test/test-jpeg.jpg",
|
|
expected: "image/jpeg",
|
|
},
|
|
{
|
|
name: "big size PNG",
|
|
path: "./test/test-png-noalphachannel.png",
|
|
expected: "image/png",
|
|
},
|
|
{
|
|
name: "small size JPEG",
|
|
path: "./test/test-jpeg-1x1px-white.jpg",
|
|
expected: "image/jpeg",
|
|
},
|
|
{
|
|
name: "golden case PNG (big size)",
|
|
path: "./test/test-png-alphachannel-1x1px.png",
|
|
expected: "image/png",
|
|
},
|
|
} {
|
|
suite.Run(test.name, func() {
|
|
ctx, cncl := context.WithTimeout(context.Background(), time.Second*60)
|
|
defer cncl()
|
|
|
|
data := func(_ context.Context) (io.ReadCloser, error) {
|
|
// load bytes from a test image
|
|
b, err := os.ReadFile(test.path)
|
|
suite.NoError(err, "Test %d: failed during test setup", index+1)
|
|
|
|
return io.NopCloser(bytes.NewBuffer(b)), nil
|
|
}
|
|
|
|
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
|
|
|
|
// process the media with no additional info provided
|
|
processing, err := suite.manager.CreateMedia(ctx,
|
|
accountID,
|
|
data,
|
|
media.AdditionalMediaInfo{},
|
|
)
|
|
suite.NoError(err)
|
|
suite.NotNil(processing)
|
|
|
|
// Load the attachment (but ignore return).
|
|
_, err = processing.Load(ctx)
|
|
suite.NoError(err)
|
|
|
|
// fetch the attachment id from the processing media
|
|
attachment, err := suite.db.GetAttachmentByID(ctx, processing.ID())
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
// make sure it's got the stuff set on it that we expect
|
|
// the attachment ID and accountID we expect
|
|
suite.Equal(processing.ID(), attachment.ID)
|
|
suite.Equal(accountID, attachment.AccountID)
|
|
|
|
actual := attachment.File.ContentType
|
|
expect := test.expected
|
|
|
|
suite.Equal(expect, actual, "Test %d: %s", index+1, test.name)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManagerTestSuite(t *testing.T) {
|
|
suite.Run(t, &ManagerTestSuite{})
|
|
}
|
|
|
|
// equalFiles checks whether
|
|
func equalFiles(t *testing.T, st *storage.Driver, storagePath, testPath string) {
|
|
b1, err := st.Get(context.Background(), storagePath)
|
|
if err != nil {
|
|
t.Fatalf("error reading file %s: %v", storagePath, err)
|
|
}
|
|
|
|
b2, err := os.ReadFile(testPath)
|
|
if err != nil {
|
|
t.Fatalf("error reading file %s: %v", testPath, err)
|
|
}
|
|
|
|
if md5.Sum(b1) != md5.Sum(b2) {
|
|
t.Errorf("%s != %s", storagePath, testPath)
|
|
}
|
|
}
|