more work on test rig

internal/apimodule/media/mediacreate_test.go

@@ -13,7 +13,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 	"github.com/superseriousbusiness/gotosocial/internal/config"
 	"github.com/superseriousbusiness/gotosocial/internal/db"
@@ -27,48 +26,43 @@ import (
 )
 
 type MediaCreateTestSuite struct {
+	// standard suite interfaces
 	suite.Suite
-	config           *config.Config
-	mockOauthServer  *oauth.MockServer
-	mockStorage      *storage.MockStorage
-	mediaHandler     media.MediaHandler
-	mastoConverter   mastotypes.Converter
+	config         *config.Config
+	db             db.DB
+	log            *logrus.Logger
+	storage        storage.Storage
+	mastoConverter mastotypes.Converter
+	mediaHandler   media.MediaHandler
+	oauthServer    oauth.Server
+
+	// standard suite models
 	testTokens       map[string]*oauth.Token
 	testClients      map[string]*oauth.Client
 	testApplications map[string]*gtsmodel.Application
 	testUsers        map[string]*gtsmodel.User
 	testAccounts     map[string]*gtsmodel.Account
-	log              *logrus.Logger
-	db               db.DB
-	mediaModule      *mediaModule
+	testAttachments  map[string]*gtsmodel.MediaAttachment
+
+	// item being tested
+	mediaModule *mediaModule
 }
 
 /*
 	TEST INFRASTRUCTURE
 */
 
-// SetupSuite sets some variables on the suite that we can use as consts (more or less) throughout
 func (suite *MediaCreateTestSuite) SetupSuite() {
-	// some of our subsequent entities need a log so create this here
-	log := logrus.New()
-	log.SetLevel(logrus.TraceLevel)
-	suite.log = log
-
-	// Direct config to local postgres instance
+	// setup standard items
 	suite.config = testrig.NewTestConfig()
+	suite.db = testrig.NewTestDB()
+	suite.log = testrig.NewTestLog()
+	suite.storage = testrig.NewTestStorage()
+	suite.mastoConverter = testrig.NewTestMastoConverter(suite.db)
+	suite.mediaHandler = testrig.NewTestMediaHandler(suite.db, suite.storage)
+	suite.oauthServer = testrig.NewTestOauthServer(suite.db)
 
-	// use an actual database for this, because it's just easier than mocking one out
-	database, err := db.New(context.Background(), suite.config, log)
-	if err != nil {
-		suite.FailNow(err.Error())
-	}
-	suite.db = database
-
-	suite.mockOauthServer = &oauth.MockServer{}
-	suite.mockStorage = &storage.MockStorage{}
-	suite.mockStorage.On("StoreFileAt", mock.AnythingOfType("string"), mock.AnythingOfType("[]uint8")).Return(nil) // just pretend to store
-	suite.mediaHandler = media.New(suite.config, suite.db, suite.mockStorage, log)
-	suite.mastoConverter = mastotypes.New(suite.config, suite.db)
+	// setup module being tested
 	suite.mediaModule = New(suite.db, suite.mediaHandler, suite.mastoConverter, suite.config, suite.log).(*mediaModule)
 }
 
@@ -80,16 +74,18 @@ func (suite *MediaCreateTestSuite) TearDownSuite() {
 
 func (suite *MediaCreateTestSuite) SetupTest() {
 	testrig.StandardDBSetup(suite.db)
+	testrig.StandardStorageSetup(suite.storage, "../../../testrig/media")
 	suite.testTokens = testrig.NewTestTokens()
 	suite.testClients = testrig.NewTestClients()
 	suite.testApplications = testrig.NewTestApplications()
 	suite.testUsers = testrig.NewTestUsers()
 	suite.testAccounts = testrig.NewTestAccounts()
+	suite.testAttachments = testrig.NewTestAttachments()
 }
 
-// TearDownTest drops tables to make sure there's no data in the db
 func (suite *MediaCreateTestSuite) TearDownTest() {
 	testrig.StandardDBTeardown(suite.db)
+	testrig.StandardStorageTeardown(suite.storage)
 }
 
 /*
@@ -98,28 +94,42 @@ func (suite *MediaCreateTestSuite) TearDownTest() {
 
 func (suite *MediaCreateTestSuite) TestStatusCreatePOSTImageHandlerSuccessful() {
 
+	// set up the context for the request
 	t := suite.testTokens["local_account_1"]
 	oauthToken := oauth.PGTokenToOauthToken(t)
-
-	// setup
 	recorder := httptest.NewRecorder()
 	ctx, _ := gin.CreateTestContext(recorder)
 	ctx.Set(oauth.SessionAuthorizedApplication, suite.testApplications["application_1"])
 	ctx.Set(oauth.SessionAuthorizedToken, oauthToken)
 	ctx.Set(oauth.SessionAuthorizedUser, suite.testUsers["local_account_1"])
 	ctx.Set(oauth.SessionAuthorizedAccount, suite.testAccounts["local_account_1"])
-	buf, w, err := testrig.CreateMultipartFormData("file", "../../media/test/test-jpeg.jpg", map[string]string{
+
+	// see what's in storage *before* the request
+	storageKeysBeforeRequest, err := suite.storage.ListKeys()
+	if err != nil {
+		panic(err)
+	}
+
+	// create the request
+	buf, w, err := testrig.CreateMultipartFormData("file", "../../../testrig/media/test-jpeg.jpg", map[string]string{
 		"description": "this is a test image -- a cool background from somewhere",
 		"focus":       "-0.5,0.5",
 	})
 	if err != nil {
 		panic(err)
 	}
-
 	ctx.Request = httptest.NewRequest(http.MethodPost, fmt.Sprintf("http://localhost:8080/%s", basePath), bytes.NewReader(buf.Bytes())) // the endpoint we're hitting
 	ctx.Request.Header.Set("Content-Type", w.FormDataContentType())
+
+	// do the actual request
 	suite.mediaModule.mediaCreatePOSTHandler(ctx)
 
+	// check what's in storage *after* the request
+	storageKeysAfterRequest, err := suite.storage.ListKeys()
+	if err != nil {
+		panic(err)
+	}
+
 	// check response
 	suite.EqualValues(http.StatusAccepted, recorder.Code)
 
@@ -157,6 +167,7 @@ func (suite *MediaCreateTestSuite) TestStatusCreatePOSTImageHandlerSuccessful()
 	assert.NotEmpty(suite.T(), attachmentReply.ID)
 	assert.NotEmpty(suite.T(), attachmentReply.URL)
 	assert.NotEmpty(suite.T(), attachmentReply.PreviewURL)
+	assert.Equal(suite.T(), len(storageKeysBeforeRequest) + 2, len(storageKeysAfterRequest)) // 2 images should be added to storage: the original and the thumbnail
 }
 
 func TestMediaCreateTestSuite(t *testing.T) {