ec1f89217a
Full Mattermost server source with integrated Community Enterprise features. Includes vendor directory for offline/air-gapped builds. Structure: - enterprise-impl/: Enterprise feature implementations - enterprise-community/: Init files that register implementations - enterprise/: Bridge imports (community_imports.go) - vendor/: All dependencies for offline builds Build (online): go build ./cmd/mattermost Build (offline/air-gapped): go build -mod=vendor ./cmd/mattermost 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
766 lines
23 KiB
Go
766 lines
23 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package app
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/mattermost/mattermost/server/public/model"
|
|
"github.com/mattermost/mattermost/server/v8/channels/store"
|
|
storemocks "github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks"
|
|
"github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestGetServerLimits(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
|
|
t.Run("unlicensed server shows hard-coded limits", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// InitBasic creates 3 users by default
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
require.Equal(t, int64(200), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(250), serverLimits.MaxUsersHardLimit)
|
|
})
|
|
|
|
t.Run("user count should increase on creating new user and decrease on permanently deleting", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
|
|
// now we create a new user
|
|
newUser := th.CreateUser()
|
|
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(4), serverLimits.ActiveUserCount)
|
|
|
|
// now we'll delete the user
|
|
_ = th.App.PermanentDeleteUser(th.Context, newUser)
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
})
|
|
|
|
t.Run("user count should increase on creating new guest user and decrease on permanently deleting", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
|
|
// now we create a new user
|
|
newGuestUser := th.CreateGuest()
|
|
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(4), serverLimits.ActiveUserCount)
|
|
|
|
// now we'll delete the user
|
|
_ = th.App.PermanentDeleteUser(th.Context, newGuestUser)
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
})
|
|
|
|
t.Run("user count should increase on creating new user and decrease on soft deleting", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
|
|
// now we create a new user
|
|
newUser := th.CreateUser()
|
|
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(4), serverLimits.ActiveUserCount)
|
|
|
|
// now we'll delete the user
|
|
_, appErr = th.App.UpdateActive(th.Context, newUser, false)
|
|
require.Nil(t, appErr)
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
})
|
|
|
|
t.Run("user count should increase on creating new guest user and decrease on soft deleting", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
|
|
// now we create a new user
|
|
newGuestUser := th.CreateGuest()
|
|
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(4), serverLimits.ActiveUserCount)
|
|
|
|
// now we'll delete the user
|
|
_, appErr = th.App.UpdateActive(th.Context, newGuestUser, false)
|
|
require.Nil(t, appErr)
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
})
|
|
|
|
t.Run("user count should not change on creating or deleting bots", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
|
|
// now we create a new bot
|
|
newBot := th.CreateBot()
|
|
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
|
|
// now we'll delete the bot
|
|
_ = th.App.PermanentDeleteBot(th.Context, newBot.UserId)
|
|
serverLimits, appErr = th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
})
|
|
|
|
t.Run("licensed server without seat count enforcement shows no limits", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = false
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
require.Greater(t, serverLimits.ActiveUserCount, int64(0))
|
|
require.Equal(t, int64(0), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(0), serverLimits.MaxUsersHardLimit)
|
|
})
|
|
|
|
t.Run("licensed server with seat count enforcement shows license limits with configurable extra users", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 100
|
|
extraUsers := 10
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
license.ExtraUsers = &extraUsers
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// InitBasic creates 3 users by default
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
require.Equal(t, int64(100), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(110), serverLimits.MaxUsersHardLimit) // 100 + 10 extra users = 110
|
|
})
|
|
|
|
t.Run("licensed server with seat count enforcement and no ExtraUsers configured defaults to zero", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 100
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
license.ExtraUsers = nil // Not configured
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// InitBasic creates 3 users by default
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
require.Equal(t, int64(100), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(100), serverLimits.MaxUsersHardLimit) // 100 + 0 extra users = 100 (hard cap)
|
|
})
|
|
|
|
t.Run("licensed server with seat count enforcement and zero ExtraUsers creates hard cap", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 100
|
|
extraUsers := 0
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
license.ExtraUsers = &extraUsers
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// InitBasic creates 3 users by default
|
|
require.Equal(t, int64(3), serverLimits.ActiveUserCount)
|
|
require.Equal(t, int64(100), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(100), serverLimits.MaxUsersHardLimit) // 100 + 0 extra users = 100 (hard cap)
|
|
})
|
|
|
|
t.Run("licensed server with seat count enforcement but no Users feature shows no limits", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = nil
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
require.Greater(t, serverLimits.ActiveUserCount, int64(0))
|
|
require.Equal(t, int64(0), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(0), serverLimits.MaxUsersHardLimit)
|
|
})
|
|
|
|
t.Run("licensed server with seat count enforcement and zero Users shows zero limits", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 0
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
require.Greater(t, serverLimits.ActiveUserCount, int64(0))
|
|
require.Equal(t, int64(0), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(0), serverLimits.MaxUsersHardLimit) // 0 + 0 (default) extra users = 0
|
|
})
|
|
}
|
|
|
|
func TestIsAtUserLimit(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
|
|
t.Run("unlicensed server", func(t *testing.T) {
|
|
t.Run("below hard limit", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(200), nil) // Under hard limit of 250
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.False(t, atLimit)
|
|
})
|
|
|
|
t.Run("at hard limit", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(250), nil) // At hard limit of 250
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.True(t, atLimit)
|
|
})
|
|
|
|
t.Run("above hard limit", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(300), nil) // Over hard limit of 250
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.True(t, atLimit)
|
|
})
|
|
})
|
|
|
|
t.Run("licensed server with seat count enforcement", func(t *testing.T) {
|
|
t.Run("below base limit", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 5
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
// InitBasic creates 3 users, so we're below the base limit of 5 and grace limit of 6
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.False(t, atLimit)
|
|
})
|
|
|
|
t.Run("at base limit but below hard limit with extra users", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 5
|
|
extraUsers := 2
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
license.ExtraUsers = &extraUsers
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
// Create 2 additional users to have 5 total (at base limit of 5, but below hard limit of 7)
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.False(t, atLimit) // Should be false due to extra users
|
|
})
|
|
|
|
t.Run("at hard limit with extra users", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
userLimit := 5
|
|
extraUsers := 1
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
license.ExtraUsers = &extraUsers
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(6), nil) // At hard limit of 6 (5 + 1)
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.True(t, atLimit)
|
|
})
|
|
|
|
t.Run("above hard limit with extra users", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
userLimit := 5
|
|
extraUsers := 1
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &userLimit
|
|
license.ExtraUsers = &extraUsers
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(7), nil) // Above hard limit of 6
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.True(t, atLimit)
|
|
})
|
|
})
|
|
|
|
t.Run("licensed server without seat count enforcement", func(t *testing.T) {
|
|
t.Run("below unenforced limit", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 5
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = false
|
|
license.Features.Users = &userLimit
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
// Create 2 additional users to have 3 total (below limit of 5)
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.False(t, atLimit)
|
|
})
|
|
|
|
t.Run("at unenforced limit", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 5
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = false
|
|
license.Features.Users = &userLimit
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
// Create 4 additional users to have 5 total (at limit of 5)
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.False(t, atLimit)
|
|
})
|
|
|
|
t.Run("above unenforced limit", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
userLimit := 5
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = false
|
|
license.Features.Users = &userLimit
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
// Create 5 additional users to have 6 total (above limit of 5)
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
th.CreateUser()
|
|
|
|
atLimit, appErr := th.App.isAtUserLimit()
|
|
require.Nil(t, appErr)
|
|
require.False(t, atLimit)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestExtraUsersBehavior(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
|
|
t.Run("extra users examples", func(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
licenseUserLimit int
|
|
extraUsers *int
|
|
expectedBaseLimit int64
|
|
expectedHardLimit int64
|
|
}{
|
|
{
|
|
name: "zero license users with extra users",
|
|
licenseUserLimit: 0,
|
|
extraUsers: model.NewPointer(5),
|
|
expectedBaseLimit: 0,
|
|
expectedHardLimit: 5, // 0 + 5 extra users = 5
|
|
},
|
|
{
|
|
name: "license with configured extra users",
|
|
licenseUserLimit: 10,
|
|
extraUsers: model.NewPointer(2),
|
|
expectedBaseLimit: 10,
|
|
expectedHardLimit: 12, // 10 + 2 extra users = 12
|
|
},
|
|
{
|
|
name: "license with zero extra users (hard cap)",
|
|
licenseUserLimit: 100,
|
|
extraUsers: model.NewPointer(0),
|
|
expectedBaseLimit: 100,
|
|
expectedHardLimit: 100, // 100 + 0 extra users = 100 (hard cap)
|
|
},
|
|
{
|
|
name: "license with no extra users configured defaults to zero",
|
|
licenseUserLimit: 100,
|
|
extraUsers: nil,
|
|
expectedBaseLimit: 100,
|
|
expectedHardLimit: 100, // 100 + 0 (default) extra users = 100 (hard cap)
|
|
},
|
|
{
|
|
name: "license with large number of extra users",
|
|
licenseUserLimit: 1000,
|
|
extraUsers: model.NewPointer(200),
|
|
expectedBaseLimit: 1000,
|
|
expectedHardLimit: 1200, // 1000 + 200 extra users = 1200
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.IsSeatCountEnforced = true
|
|
license.Features.Users = &tt.licenseUserLimit
|
|
license.ExtraUsers = tt.extraUsers
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
require.Equal(t, tt.expectedBaseLimit, serverLimits.MaxUsersLimit)
|
|
require.Equal(t, tt.expectedHardLimit, serverLimits.MaxUsersHardLimit)
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("unlicensed server has no extra users", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// Unlicensed servers use hard-coded limits without extra users
|
|
require.Equal(t, int64(200), serverLimits.MaxUsersLimit)
|
|
require.Equal(t, int64(250), serverLimits.MaxUsersHardLimit)
|
|
})
|
|
}
|
|
|
|
func TestGetServerLimitsWithPostHistory(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
|
|
t.Run("unlicensed server has no post history limits", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// Unlicensed servers should have no post history limits
|
|
require.Equal(t, int64(0), serverLimits.PostHistoryLimit)
|
|
require.Equal(t, int64(0), serverLimits.LastAccessiblePostTime)
|
|
})
|
|
|
|
t.Run("licensed server without post history limits", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.Limits = nil // No limits configured
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// Should have no post history limits when Limits is nil
|
|
require.Equal(t, int64(0), serverLimits.PostHistoryLimit)
|
|
require.Equal(t, int64(0), serverLimits.LastAccessiblePostTime)
|
|
})
|
|
|
|
t.Run("licensed server with zero post history limit", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.Limits = &model.LicenseLimits{
|
|
PostHistory: 0, // Zero limit
|
|
}
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// Should have no post history limits when PostHistory is 0
|
|
require.Equal(t, int64(0), serverLimits.PostHistoryLimit)
|
|
require.Equal(t, int64(0), serverLimits.LastAccessiblePostTime)
|
|
})
|
|
|
|
t.Run("licensed server with positive post history limit and successful GetLastAccessiblePostTime", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
// Mock user store for existing functionality
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(5), nil)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
// Mock system store for GetLastAccessiblePostTime
|
|
mockSystemStore := storemocks.SystemStore{}
|
|
mockSystemStore.On("GetByName", model.SystemLastAccessiblePostTime).Return(&model.System{
|
|
Name: model.SystemLastAccessiblePostTime,
|
|
Value: "1234567890",
|
|
}, nil)
|
|
mockStore.On("System").Return(&mockSystemStore)
|
|
|
|
// Create Entry license with post history limit
|
|
license := model.NewTestLicenseSKU(model.LicenseShortSkuMattermostEntry)
|
|
license.Limits = &model.LicenseLimits{
|
|
PostHistory: 1000,
|
|
}
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// Should have proper post history limits set
|
|
require.Equal(t, int64(1000), serverLimits.PostHistoryLimit)
|
|
require.Equal(t, int64(1234567890), serverLimits.LastAccessiblePostTime)
|
|
require.Equal(t, int64(5), serverLimits.ActiveUserCount)
|
|
})
|
|
|
|
t.Run("licensed server with post history limit but GetLastAccessiblePostTime fails", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
// Mock user store for existing functionality
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(5), nil)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
// Mock system store to return error
|
|
mockSystemStore := storemocks.SystemStore{}
|
|
mockSystemStore.On("GetByName", model.SystemLastAccessiblePostTime).Return(nil, errors.New("database error"))
|
|
mockStore.On("System").Return(&mockSystemStore)
|
|
|
|
// Create Entry license with post history limit
|
|
license := model.NewTestLicenseSKU(model.LicenseShortSkuMattermostEntry)
|
|
license.Limits = &model.LicenseLimits{
|
|
PostHistory: 1000,
|
|
}
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
_, appErr := th.App.GetServerLimits()
|
|
require.NotNil(t, appErr)
|
|
require.Contains(t, appErr.Message, "Unable to find the system variable")
|
|
})
|
|
|
|
t.Run("licensed server with post history limit but no system value found", func(t *testing.T) {
|
|
th := SetupWithStoreMock(t)
|
|
defer th.TearDown()
|
|
|
|
// Mock user store for existing functionality
|
|
mockStore := th.App.Srv().Store().(*storemocks.Store)
|
|
mockUserStore := storemocks.UserStore{}
|
|
mockUserStore.On("Count", mock.Anything).Return(int64(5), nil)
|
|
mockStore.On("User").Return(&mockUserStore)
|
|
|
|
// Mock system store to return ErrNotFound (all posts accessible)
|
|
mockSystemStore := storemocks.SystemStore{}
|
|
mockSystemStore.On("GetByName", model.SystemLastAccessiblePostTime).Return(nil, store.NewErrNotFound("", ""))
|
|
mockStore.On("System").Return(&mockSystemStore)
|
|
|
|
// Create Entry license with post history limit
|
|
license := model.NewTestLicenseSKU(model.LicenseShortSkuMattermostEntry)
|
|
license.Limits = &model.LicenseLimits{
|
|
PostHistory: 1000,
|
|
}
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
serverLimits, appErr := th.App.GetServerLimits()
|
|
require.Nil(t, appErr)
|
|
|
|
// Should have post history limit set but LastAccessiblePostTime should be 0 (all posts accessible)
|
|
require.Equal(t, int64(1000), serverLimits.PostHistoryLimit)
|
|
require.Equal(t, int64(0), serverLimits.LastAccessiblePostTime)
|
|
require.Equal(t, int64(5), serverLimits.ActiveUserCount)
|
|
})
|
|
}
|
|
func TestGetPostHistoryLimit(t *testing.T) {
|
|
mainHelper.Parallel(t)
|
|
|
|
t.Run("unlicensed server returns zero limit", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
th.App.Srv().SetLicense(nil)
|
|
|
|
limit := th.App.GetPostHistoryLimit()
|
|
require.Equal(t, int64(0), limit)
|
|
})
|
|
|
|
t.Run("licensed server with no Limits returns zero", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.Limits = nil // No limits configured
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
limit := th.App.GetPostHistoryLimit()
|
|
require.Equal(t, int64(0), limit)
|
|
})
|
|
|
|
t.Run("licensed server with zero PostHistory returns zero", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.Limits = &model.LicenseLimits{
|
|
PostHistory: 0,
|
|
}
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
limit := th.App.GetPostHistoryLimit()
|
|
require.Equal(t, int64(0), limit)
|
|
})
|
|
|
|
t.Run("licensed server with positive PostHistory returns exact value", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicense("")
|
|
license.Limits = &model.LicenseLimits{
|
|
PostHistory: 1500,
|
|
}
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
limit := th.App.GetPostHistoryLimit()
|
|
require.Equal(t, int64(1500), limit)
|
|
})
|
|
|
|
t.Run("Entry license with PostHistory returns exact value", func(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
license := model.NewTestLicenseSKU(model.LicenseShortSkuMattermostEntry)
|
|
|
|
license.Limits = &model.LicenseLimits{
|
|
PostHistory: 2000,
|
|
}
|
|
th.App.Srv().SetLicense(license)
|
|
|
|
limit := th.App.GetPostHistoryLimit()
|
|
require.Equal(t, int64(2000), limit)
|
|
})
|
|
}
|