1
0
mirror of https://github.com/mattermost/focalboard.git synced 2024-12-21 13:38:56 +02:00
focalboard/server/auth/auth_test.go
Rajat Dabade c8e729b6fe
[Refactor]: updated dependency for focalboard server (#5009)
* refactor: updated dependency for focalboard server

* chore: more dependency fixes

* refactor: removed the unless code

* refactor: added ctx for login and removed unnessary code

* refactor: bump up go version

* refactor: removed the commented code

* chore: upgraded golinter version

* fix: linter issue

* refactor: removed feature flg fix golinter

* refactor: removed feature flag from code

* revert: statistic and it's function

* refactor: removed ProductLimit related code

* refactor: removed isWithinViewsLimit implementation

* refactor: moved function GetUsedCardsCount to statistics.go from cloud.go

* refactor: removed insight code board

* refactor: removed limit dialog

* refactor: updated dependencies for linux

* chore: golinter fix

* chore: updated helper test function to use newLogger

* fix: go test

* refactor: db ping attempts from config

* revert: feature in action

* revert: feature flag in action

* revert: boardsEditor setting

---------

Co-authored-by: Rajat Dabade <rajat@Rajats-MacBook-Pro.local>
2024-06-07 23:30:08 +05:30

145 lines
4.6 KiB
Go

package auth
import (
"testing"
"github.com/golang/mock/gomock"
"github.com/mattermost/focalboard/server/model"
"github.com/mattermost/focalboard/server/services/config"
"github.com/mattermost/focalboard/server/services/permissions/localpermissions"
mockpermissions "github.com/mattermost/focalboard/server/services/permissions/mocks"
"github.com/mattermost/focalboard/server/services/store/mockstore"
"github.com/mattermost/focalboard/server/utils"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
"github.com/mattermost/mattermost/server/public/shared/mlog"
)
type TestHelper struct {
Auth *Auth
Session model.Session
Store *mockstore.MockStore
}
var mockSession = &model.Session{
ID: utils.NewID(utils.IDTypeSession),
Token: "goodToken",
UserID: "12345",
CreateAt: utils.GetMillis() - utils.SecondsToMillis(2000),
UpdateAt: utils.GetMillis() - utils.SecondsToMillis(2000),
}
func setupTestHelper(t *testing.T) *TestHelper {
ctrl := gomock.NewController(t)
ctrlPermissions := gomock.NewController(t)
cfg := config.Configuration{}
mockStore := mockstore.NewMockStore(ctrl)
mockPermissions := mockpermissions.NewMockStore(ctrlPermissions)
logger, err := mlog.NewLogger()
require.NoError(t, err)
newAuth := New(&cfg, mockStore, localpermissions.New(mockPermissions, logger))
// called during default template setup for every test
mockStore.EXPECT().GetTemplateBoards("0", "").AnyTimes()
mockStore.EXPECT().RemoveDefaultTemplates(gomock.Any()).AnyTimes()
mockStore.EXPECT().InsertBlock(gomock.Any(), gomock.Any()).AnyTimes()
return &TestHelper{
Auth: newAuth,
Session: *mockSession,
Store: mockStore,
}
}
func TestGetSession(t *testing.T) {
th := setupTestHelper(t)
testcases := []struct {
title string
token string
refreshTime int64
isError bool
}{
{"fail, no token", "", 0, true},
{"fail, invalid username", "badToken", 0, true},
{"success, good token", "goodToken", 1000, false},
}
th.Store.EXPECT().GetSession("badToken", gomock.Any()).Return(nil, errors.New("Invalid Token"))
th.Store.EXPECT().GetSession("goodToken", gomock.Any()).Return(mockSession, nil)
th.Store.EXPECT().RefreshSession(gomock.Any()).Return(nil)
for _, test := range testcases {
t.Run(test.title, func(t *testing.T) {
if test.refreshTime > 0 {
th.Auth.config.SessionRefreshTime = test.refreshTime
}
session, err := th.Auth.GetSession(test.token)
if test.isError {
require.Error(t, err)
} else {
require.NoError(t, err)
require.NotNil(t, session)
}
})
}
}
func TestIsValidReadToken(t *testing.T) {
// ToDo: reimplement
// th := setupTestHelper(t)
// validBlockID := "testBlockID"
// mockContainer := store.Container{
// TeamID: "testTeamID",
// }
// validReadToken := "testReadToken"
// mockSharing := model.Sharing{
// ID: "testRootID",
// Enabled: true,
// Token: validReadToken,
// }
// testcases := []struct {
// title string
// container store.Container
// blockID string
// readToken string
// isError bool
// isSuccess bool
// }{
// {"fail, error GetRootID", mockContainer, "badBlock", "", true, false},
// {"fail, rootID not found", mockContainer, "goodBlockID", "", false, false},
// {"fail, sharing throws error", mockContainer, "goodBlockID2", "", true, false},
// {"fail, bad readToken", mockContainer, validBlockID, "invalidReadToken", false, false},
// {"success", mockContainer, validBlockID, validReadToken, false, true},
// }
// th.Store.EXPECT().GetRootID(gomock.Eq(mockContainer), "badBlock").Return("", errors.New("invalid block"))
// th.Store.EXPECT().GetRootID(gomock.Eq(mockContainer), "goodBlockID").Return("rootNotFound", nil)
// th.Store.EXPECT().GetRootID(gomock.Eq(mockContainer), "goodBlockID2").Return("rootError", nil)
// th.Store.EXPECT().GetRootID(gomock.Eq(mockContainer), validBlockID).Return("testRootID", nil).Times(2)
// th.Store.EXPECT().GetSharing(gomock.Eq(mockContainer), "rootNotFound").Return(nil, sql.ErrNoRows)
// th.Store.EXPECT().GetSharing(gomock.Eq(mockContainer), "rootError").Return(nil, errors.New("another error"))
// th.Store.EXPECT().GetSharing(gomock.Eq(mockContainer), "testRootID").Return(&mockSharing, nil).Times(2)
// for _, test := range testcases {
// t.Run(test.title, func(t *testing.T) {
// success, err := th.Auth.IsValidReadToken(test.container, test.blockID, test.readToken)
// if test.isError {
// require.Error(t, err)
// } else {
// require.NoError(t, err)
// }
// if test.isSuccess {
// require.True(t, success)
// } else {
// require.False(t, success)
// }
// })
// }
}