mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

Merge branch 'master' into mark-as-unread

Просмотр исходного кода
Этот коммит содержится в:
Harrison Healey
2019-11-07 10:58:09 -05:00
родитель 47409aaa4b 540cfb0239
Коммит 6e6174a9ee
41 изменённых файлов: 1565 добавлений и 1907 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

125
store/storetest/emoji_store.go
Просмотреть файл

@@ -30,33 +30,26 @@ func testEmojiSaveDelete(t *testing.T, ss store.Store) {
Name: model.NewId(),
}
if _, err := ss.Emoji().Save(emoji1); err != nil {
t.Fatal(err)
}
_, err := ss.Emoji().Save(emoji1)
require.Nil(t, err)
if len(emoji1.Id) != 26 {
t.Fatal("should've set id for emoji")
}
assert.Len(t, emoji1.Id, 26, "should've set id for emoji")
emoji2 := model.Emoji{
CreatorId: model.NewId(),
Name: emoji1.Name,
}
if _, err := ss.Emoji().Save(&emoji2); err == nil {
t.Fatal("shouldn't be able to save emoji with duplicate name")
}
_, err = ss.Emoji().Save(&emoji2)
require.NotNil(t, err, "shouldn't be able to save emoji with duplicate name")
if err := ss.Emoji().Delete(emoji1, time.Now().Unix()); err != nil {
t.Fatal(err)
}
err = ss.Emoji().Delete(emoji1, time.Now().Unix())
require.Nil(t, err)
if _, err := ss.Emoji().Save(&emoji2); err != nil {
t.Fatal("should be able to save emoji with duplicate name now that original has been deleted", err)
}
_, err = ss.Emoji().Save(&emoji2)
require.Nil(t, err, "should be able to save emoji with duplicate name now that original has been deleted")
if err := ss.Emoji().Delete(&emoji2, time.Now().Unix()+1); err != nil {
t.Fatal(err)
}
err = ss.Emoji().Delete(&emoji2, time.Now().Unix()+1)
require.Nil(t, err)
}
func testEmojiGet(t *testing.T, ss store.Store) {
@@ -88,15 +81,13 @@ func testEmojiGet(t *testing.T, ss store.Store) {
}()
for _, emoji := range emojis {
if _, err := ss.Emoji().Get(emoji.Id, false); err != nil {
t.Fatalf("failed to get emoji with id %v: %v", emoji.Id, err)
}
_, err := ss.Emoji().Get(emoji.Id, false)
require.Nilf(t, err, "failed to get emoji with id %v", emoji.Id)
}
for _, emoji := range emojis {
if _, err := ss.Emoji().Get(emoji.Id, true); err != nil {
t.Fatalf("failed to get emoji with id %v: %v", emoji.Id, err)
}
_, err := ss.Emoji().Get(emoji.Id, true)
require.Nilf(t, err, "failed to get emoji with id %v", emoji.Id)
}
}
@@ -184,9 +175,8 @@ func testEmojiGetByName(t *testing.T, ss store.Store) {
}()
for _, emoji := range emojis {
if _, err := ss.Emoji().GetByName(emoji.Name, true); err != nil {
t.Fatalf("failed to get emoji with name %v: %v", emoji.Name, err)
}
_, err := ss.Emoji().GetByName(emoji.Name, true)
require.Nilf(t, err, "failed to get emoji with name %v", emoji.Name)
}
}
@@ -219,35 +209,28 @@ func testEmojiGetMultipleByName(t *testing.T, ss store.Store) {
}()
t.Run("one emoji", func(t *testing.T) {
if received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name}); err != nil {
t.Fatal("could not get emoji", err)
} else if len(received) != 1 || *received[0] != emojis[0] {
t.Fatal("got incorrect emoji")
}
received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name})
require.Nilf(t, err, "could not get emoji")
require.Len(t, received, 1, "got incorrect emoji")
require.Equal(t, *received[0], emojis[0], "got incorrect emoji")
})
t.Run("multiple emojis", func(t *testing.T) {
if received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name, emojis[1].Name, emojis[2].Name}); err != nil {
t.Fatal("could not get emojis", err)
} else if len(received) != 3 {
t.Fatal("got incorrect emojis")
}
received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name, emojis[1].Name, emojis[2].Name})
require.Nil(t, err, "could not get emojis")
require.Len(t, received, 3, "got incorrect emojis")
})
t.Run("one nonexistent emoji", func(t *testing.T) {
if received, err := ss.Emoji().GetMultipleByName([]string{"ab"}); err != nil {
t.Fatal("could not get emoji", err)
} else if len(received) != 0 {
t.Fatal("got incorrect emoji")
}
received, err := ss.Emoji().GetMultipleByName([]string{"ab"})
require.Nilf(t, err, "%v, could not get emoji", err)
require.Len(t, received, 0, "got incorrect emoji")
})
t.Run("multiple emojis with nonexistent names", func(t *testing.T) {
if received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name, emojis[1].Name, emojis[2].Name, "abcd", "1234"}); err != nil {
t.Fatal("could not get emojis", err)
} else if len(received) != 3 {
t.Fatal("got incorrect emojis")
}
received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name, emojis[1].Name, emojis[2].Name, "abcd", "1234"})
require.Nil(t, err, "could not get emojis")
require.Len(t, received, 3, "got incorrect emojis")
})
}
@@ -292,9 +275,7 @@ func testEmojiGetList(t *testing.T, ss store.Store) {
}
}
if !found {
t.Fatalf("failed to get emoji with id %v", emoji.Id)
}
require.Truef(t, found, "failed to get emoji with id %v", emoji.Id)
}
}
@@ -347,38 +328,34 @@ func testEmojiSearch(t *testing.T, ss store.Store) {
shouldFind := []bool{true, false, false, false}
if result, err := ss.Emoji().Search("blargh", true, 100); err != nil {
t.Fatal(err)
} else {
for i, emoji := range emojis {
found := false
result, err := ss.Emoji().Search("blargh", true, 100)
require.Nil(t, err)
for i, emoji := range emojis {
found := false
for _, savedEmoji := range result {
if emoji.Id == savedEmoji.Id {
found = true
break
}
for _, savedEmoji := range result {
if emoji.Id == savedEmoji.Id {
found = true
break
}
assert.Equal(t, shouldFind[i], found, emoji.Name)
}
assert.Equal(t, shouldFind[i], found, emoji.Name)
}
shouldFind = []bool{true, true, true, false}
if result, err := ss.Emoji().Search("blargh", false, 100); err != nil {
t.Fatal(err)
} else {
for i, emoji := range emojis {
found := false
result, err = ss.Emoji().Search("blargh", false, 100)
require.Nil(t, err)
for i, emoji := range emojis {
found := false
for _, savedEmoji := range result {
if emoji.Id == savedEmoji.Id {
found = true
break
}
for _, savedEmoji := range result {
if emoji.Id == savedEmoji.Id {
found = true
break
}
assert.Equal(t, shouldFind[i], found, emoji.Name)
}
assert.Equal(t, shouldFind[i], found, emoji.Name)
}
}

629
store/storetest/mocks/LayeredStoreDatabaseLayer.go
Просмотреть файл

@@ -1,629 +0,0 @@
// Code generated by mockery v1.0.0. DO NOT EDIT.
// Regenerate this file using `make store-mocks`.
package mocks
import (
store "github.com/mattermost/mattermost-server/store"
mock "github.com/stretchr/testify/mock"
)
// LayeredStoreDatabaseLayer is an autogenerated mock type for the LayeredStoreDatabaseLayer type
type LayeredStoreDatabaseLayer struct {
mock.Mock
}
// Audit provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Audit() store.AuditStore {
ret := _m.Called()
var r0 store.AuditStore
if rf, ok := ret.Get(0).(func() store.AuditStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.AuditStore)
}
}
return r0
}
// Bot provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Bot() store.BotStore {
ret := _m.Called()
var r0 store.BotStore
if rf, ok := ret.Get(0).(func() store.BotStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.BotStore)
}
}
return r0
}
// Channel provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Channel() store.ChannelStore {
ret := _m.Called()
var r0 store.ChannelStore
if rf, ok := ret.Get(0).(func() store.ChannelStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.ChannelStore)
}
}
return r0
}
// ChannelMemberHistory provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) ChannelMemberHistory() store.ChannelMemberHistoryStore {
ret := _m.Called()
var r0 store.ChannelMemberHistoryStore
if rf, ok := ret.Get(0).(func() store.ChannelMemberHistoryStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.ChannelMemberHistoryStore)
}
}
return r0
}
// CheckIntegrity provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) CheckIntegrity() <-chan store.IntegrityCheckResult {
ret := _m.Called()
var r0 <-chan store.IntegrityCheckResult
if rf, ok := ret.Get(0).(func() <-chan store.IntegrityCheckResult); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(<-chan store.IntegrityCheckResult)
}
}
return r0
}
// Close provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Close() {
_m.Called()
}
// ClusterDiscovery provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) ClusterDiscovery() store.ClusterDiscoveryStore {
ret := _m.Called()
var r0 store.ClusterDiscoveryStore
if rf, ok := ret.Get(0).(func() store.ClusterDiscoveryStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.ClusterDiscoveryStore)
}
}
return r0
}
// Command provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Command() store.CommandStore {
ret := _m.Called()
var r0 store.CommandStore
if rf, ok := ret.Get(0).(func() store.CommandStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.CommandStore)
}
}
return r0
}
// CommandWebhook provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) CommandWebhook() store.CommandWebhookStore {
ret := _m.Called()
var r0 store.CommandWebhookStore
if rf, ok := ret.Get(0).(func() store.CommandWebhookStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.CommandWebhookStore)
}
}
return r0
}
// Compliance provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Compliance() store.ComplianceStore {
ret := _m.Called()
var r0 store.ComplianceStore
if rf, ok := ret.Get(0).(func() store.ComplianceStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.ComplianceStore)
}
}
return r0
}
// DropAllTables provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) DropAllTables() {
_m.Called()
}
// Emoji provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Emoji() store.EmojiStore {
ret := _m.Called()
var r0 store.EmojiStore
if rf, ok := ret.Get(0).(func() store.EmojiStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.EmojiStore)
}
}
return r0
}
// FileInfo provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) FileInfo() store.FileInfoStore {
ret := _m.Called()
var r0 store.FileInfoStore
if rf, ok := ret.Get(0).(func() store.FileInfoStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.FileInfoStore)
}
}
return r0
}
// GetCurrentSchemaVersion provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) GetCurrentSchemaVersion() string {
ret := _m.Called()
var r0 string
if rf, ok := ret.Get(0).(func() string); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(string)
}
return r0
}
// Group provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Group() store.GroupStore {
ret := _m.Called()
var r0 store.GroupStore
if rf, ok := ret.Get(0).(func() store.GroupStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.GroupStore)
}
}
return r0
}
// Job provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Job() store.JobStore {
ret := _m.Called()
var r0 store.JobStore
if rf, ok := ret.Get(0).(func() store.JobStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.JobStore)
}
}
return r0
}
// License provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) License() store.LicenseStore {
ret := _m.Called()
var r0 store.LicenseStore
if rf, ok := ret.Get(0).(func() store.LicenseStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.LicenseStore)
}
}
return r0
}
// LinkMetadata provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) LinkMetadata() store.LinkMetadataStore {
ret := _m.Called()
var r0 store.LinkMetadataStore
if rf, ok := ret.Get(0).(func() store.LinkMetadataStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.LinkMetadataStore)
}
}
return r0
}
// LockToMaster provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) LockToMaster() {
_m.Called()
}
// MarkSystemRanUnitTests provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) MarkSystemRanUnitTests() {
_m.Called()
}
// Next provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Next() store.LayeredStoreSupplier {
ret := _m.Called()
var r0 store.LayeredStoreSupplier
if rf, ok := ret.Get(0).(func() store.LayeredStoreSupplier); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.LayeredStoreSupplier)
}
}
return r0
}
// OAuth provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) OAuth() store.OAuthStore {
ret := _m.Called()
var r0 store.OAuthStore
if rf, ok := ret.Get(0).(func() store.OAuthStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.OAuthStore)
}
}
return r0
}
// Plugin provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Plugin() store.PluginStore {
ret := _m.Called()
var r0 store.PluginStore
if rf, ok := ret.Get(0).(func() store.PluginStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.PluginStore)
}
}
return r0
}
// Post provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Post() store.PostStore {
ret := _m.Called()
var r0 store.PostStore
if rf, ok := ret.Get(0).(func() store.PostStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.PostStore)
}
}
return r0
}
// Preference provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Preference() store.PreferenceStore {
ret := _m.Called()
var r0 store.PreferenceStore
if rf, ok := ret.Get(0).(func() store.PreferenceStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.PreferenceStore)
}
}
return r0
}
// Reaction provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Reaction() store.ReactionStore {
ret := _m.Called()
var r0 store.ReactionStore
if rf, ok := ret.Get(0).(func() store.ReactionStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.ReactionStore)
}
}
return r0
}
// Role provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Role() store.RoleStore {
ret := _m.Called()
var r0 store.RoleStore
if rf, ok := ret.Get(0).(func() store.RoleStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.RoleStore)
}
}
return r0
}
// Scheme provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Scheme() store.SchemeStore {
ret := _m.Called()
var r0 store.SchemeStore
if rf, ok := ret.Get(0).(func() store.SchemeStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.SchemeStore)
}
}
return r0
}
// Session provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Session() store.SessionStore {
ret := _m.Called()
var r0 store.SessionStore
if rf, ok := ret.Get(0).(func() store.SessionStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.SessionStore)
}
}
return r0
}
// SetChainNext provides a mock function with given fields: _a0
func (_m *LayeredStoreDatabaseLayer) SetChainNext(_a0 store.LayeredStoreSupplier) {
_m.Called(_a0)
}
// Status provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Status() store.StatusStore {
ret := _m.Called()
var r0 store.StatusStore
if rf, ok := ret.Get(0).(func() store.StatusStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StatusStore)
}
}
return r0
}
// System provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) System() store.SystemStore {
ret := _m.Called()
var r0 store.SystemStore
if rf, ok := ret.Get(0).(func() store.SystemStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.SystemStore)
}
}
return r0
}
// Team provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Team() store.TeamStore {
ret := _m.Called()
var r0 store.TeamStore
if rf, ok := ret.Get(0).(func() store.TeamStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.TeamStore)
}
}
return r0
}
// TermsOfService provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) TermsOfService() store.TermsOfServiceStore {
ret := _m.Called()
var r0 store.TermsOfServiceStore
if rf, ok := ret.Get(0).(func() store.TermsOfServiceStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.TermsOfServiceStore)
}
}
return r0
}
// Token provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Token() store.TokenStore {
ret := _m.Called()
var r0 store.TokenStore
if rf, ok := ret.Get(0).(func() store.TokenStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.TokenStore)
}
}
return r0
}
// TotalMasterDbConnections provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) TotalMasterDbConnections() int {
ret := _m.Called()
var r0 int
if rf, ok := ret.Get(0).(func() int); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(int)
}
return r0
}
// TotalReadDbConnections provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) TotalReadDbConnections() int {
ret := _m.Called()
var r0 int
if rf, ok := ret.Get(0).(func() int); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(int)
}
return r0
}
// TotalSearchDbConnections provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) TotalSearchDbConnections() int {
ret := _m.Called()
var r0 int
if rf, ok := ret.Get(0).(func() int); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(int)
}
return r0
}
// UnlockFromMaster provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) UnlockFromMaster() {
_m.Called()
}
// User provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) User() store.UserStore {
ret := _m.Called()
var r0 store.UserStore
if rf, ok := ret.Get(0).(func() store.UserStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.UserStore)
}
}
return r0
}
// UserAccessToken provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) UserAccessToken() store.UserAccessTokenStore {
ret := _m.Called()
var r0 store.UserAccessTokenStore
if rf, ok := ret.Get(0).(func() store.UserAccessTokenStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.UserAccessTokenStore)
}
}
return r0
}
// UserTermsOfService provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) UserTermsOfService() store.UserTermsOfServiceStore {
ret := _m.Called()
var r0 store.UserTermsOfServiceStore
if rf, ok := ret.Get(0).(func() store.UserTermsOfServiceStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.UserTermsOfServiceStore)
}
}
return r0
}
// Webhook provides a mock function with given fields:
func (_m *LayeredStoreDatabaseLayer) Webhook() store.WebhookStore {
ret := _m.Called()
var r0 store.WebhookStore
if rf, ok := ret.Get(0).(func() store.WebhookStore); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.WebhookStore)
}
}
return r0
}

36
store/storetest/mocks/LayeredStoreSupplier.go
Просмотреть файл

@@ -1,36 +0,0 @@
// Code generated by mockery v1.0.0. DO NOT EDIT.
// Regenerate this file using `make store-mocks`.
package mocks
import (
store "github.com/mattermost/mattermost-server/store"
mock "github.com/stretchr/testify/mock"
)
// LayeredStoreSupplier is an autogenerated mock type for the LayeredStoreSupplier type
type LayeredStoreSupplier struct {
mock.Mock
}
// Next provides a mock function with given fields:
func (_m *LayeredStoreSupplier) Next() store.LayeredStoreSupplier {
ret := _m.Called()
var r0 store.LayeredStoreSupplier
if rf, ok := ret.Get(0).(func() store.LayeredStoreSupplier); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.LayeredStoreSupplier)
}
}
return r0
}
// SetChainNext provides a mock function with given fields: _a0
func (_m *LayeredStoreSupplier) SetChainNext(_a0 store.LayeredStoreSupplier) {
_m.Called(_a0)
}

534
store/storetest/team_store.go
Просмотреть файл

@@ -69,18 +69,15 @@ func testTeamStoreSave(t *testing.T, ss store.Store) {
o1.Email = MakeEmail()
o1.Type = model.TEAM_OPEN
if _, err := ss.Team().Save(&o1); err != nil {
t.Fatal("couldn't save item", err)
}
_, err := ss.Team().Save(&o1)
require.Nil(t, err, "couldn't save item")
if _, err := ss.Team().Save(&o1); err == nil {
t.Fatal("shouldn't be able to update from save")
}
_, err = ss.Team().Save(&o1)
require.NotNil(t, err, "shouldn't be able to update from save")
o1.Id = ""
if _, err := ss.Team().Save(&o1); err == nil {
t.Fatal("should be unique domain")
}
_, err = ss.Team().Save(&o1)
require.NotNil(t, err, "should be unique domain")
}
func testTeamStoreUpdate(t *testing.T, ss store.Store) {
@@ -89,25 +86,21 @@ func testTeamStoreUpdate(t *testing.T, ss store.Store) {
o1.Name = "z-z-z" + model.NewId() + "b"
o1.Email = MakeEmail()
o1.Type = model.TEAM_OPEN
if _, err := ss.Team().Save(&o1); err != nil {
t.Fatal(err)
}
_, err := ss.Team().Save(&o1)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
if _, err := ss.Team().Update(&o1); err != nil {
t.Fatal(err)
}
_, err = ss.Team().Update(&o1)
require.Nil(t, err)
o1.Id = "missing"
if _, err := ss.Team().Update(&o1); err == nil {
t.Fatal("Update should have failed because of missing key")
}
_, err = ss.Team().Update(&o1)
require.NotNil(t, err, "Update should have failed because of missing key")
o1.Id = model.NewId()
if _, err := ss.Team().Update(&o1); err == nil {
t.Fatal("Update should have faile because id change")
}
_, err = ss.Team().Update(&o1)
require.NotNil(t, err, "Update should have faile because id change")
}
func testTeamStoreGet(t *testing.T, ss store.Store) {
@@ -134,21 +127,15 @@ func testTeamStoreGetByName(t *testing.T, ss store.Store) {
o1.Email = MakeEmail()
o1.Type = model.TEAM_OPEN
if _, err := ss.Team().Save(&o1); err != nil {
t.Fatal(err)
}
_, err := ss.Team().Save(&o1)
require.Nil(t, err)
if team, err := ss.Team().GetByName(o1.Name); err != nil {
t.Fatal(err)
} else {
if team.ToJson() != o1.ToJson() {
t.Fatal("invalid returned team")
}
}
team, err := ss.Team().GetByName(o1.Name)
require.Nil(t, err)
require.Equal(t, *team, o1, "invalid returned team")
if _, err := ss.Team().GetByName(""); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Team().GetByName("")
require.NotNil(t, err, "Missing id should have failed")
}
func testTeamStoreSearchAll(t *testing.T, ss store.Store) {
@@ -363,9 +350,7 @@ func testTeamStoreGetByInviteId(t *testing.T, ss store.Store) {
o1.InviteId = model.NewId()
save1, err := ss.Team().Save(&o1)
if err != nil {
t.Fatal(err)
}
require.Nil(t, err)
o2 := model.Team{}
o2.DisplayName = "DisplayName"
@@ -373,17 +358,12 @@ func testTeamStoreGetByInviteId(t *testing.T, ss store.Store) {
o2.Email = MakeEmail()
o2.Type = model.TEAM_OPEN
if r1, err := ss.Team().GetByInviteId(save1.InviteId); err != nil {
t.Fatal(err)
} else {
if r1.ToJson() != o1.ToJson() {
t.Fatal("invalid returned team")
}
}
r1, err := ss.Team().GetByInviteId(save1.InviteId)
require.Nil(t, err)
require.Equal(t, *r1, o1, "invalid returned team")
if _, err := ss.Team().GetByInviteId(""); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Team().GetByInviteId("")
require.NotNil(t, err, "Missing id should have failed")
}
func testTeamStoreByUserId(t *testing.T, ss store.Store) {
@@ -400,18 +380,10 @@ func testTeamStoreByUserId(t *testing.T, ss store.Store) {
_, err = ss.Team().SaveMember(m1, -1)
require.Nil(t, err)
if teams, err := ss.Team().GetTeamsByUserId(m1.UserId); err != nil {
t.Fatal(err)
} else {
if len(teams) == 0 {
t.Fatal("Should return a team")
}
if teams[0].Id != o1.Id {
t.Fatal("should be a member")
}
}
teams, err := ss.Team().GetTeamsByUserId(m1.UserId)
require.Nil(t, err)
require.Len(t, teams, 1, "Should return a team")
require.Equal(t, teams[0].Id, o1.Id, "should be a member")
}
func testGetAllTeamListing(t *testing.T, ss store.Store) {
@@ -449,19 +421,13 @@ func testGetAllTeamListing(t *testing.T, ss store.Store) {
_, err = ss.Team().Save(&o4)
require.Nil(t, err)
if teams, err := ss.Team().GetAllTeamListing(); err != nil {
t.Fatal(err)
} else {
for _, team := range teams {
if !team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as true")
}
}
if len(teams) == 0 {
t.Fatal("failed team listing")
}
teams, err := ss.Team().GetAllTeamListing()
require.Nil(t, err)
for _, team := range teams {
require.True(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as true")
}
require.NotEmpty(t, teams, "failed team listing")
}
func testGetAllTeamPageListing(t *testing.T, ss store.Store) {
@@ -505,14 +471,10 @@ func testGetAllTeamPageListing(t *testing.T, ss store.Store) {
require.Nil(t, err)
for _, team := range teams {
if !team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as true")
}
require.True(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as true")
}
if len(teams) > 10 {
t.Fatal("should have returned max of 10 teams")
}
require.LessOrEqual(t, len(teams), 10, "should have returned max of 10 teams")
o5 := model.Team{}
o5.DisplayName = "DisplayName"
@@ -527,27 +489,19 @@ func testGetAllTeamPageListing(t *testing.T, ss store.Store) {
require.Nil(t, err)
for _, team := range teams {
if !team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as true")
}
require.True(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as true")
}
if len(teams) > 4 {
t.Fatal("should have returned max of 4 teams")
}
require.LessOrEqual(t, len(teams), 4, "should have returned max of 4 teams")
teams, err = ss.Team().GetAllTeamPageListing(1, 1)
require.Nil(t, err)
for _, team := range teams {
if !team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as true")
}
require.True(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as true")
}
if len(teams) > 1 {
t.Fatal("should have returned max of 1 team")
}
require.LessOrEqual(t, len(teams), 1, "should have returned max of 1 team")
}
func testGetAllPrivateTeamListing(t *testing.T, ss store.Store) {
@@ -585,18 +539,12 @@ func testGetAllPrivateTeamListing(t *testing.T, ss store.Store) {
_, err = ss.Team().Save(&o4)
require.Nil(t, err)
if teams, err := ss.Team().GetAllPrivateTeamListing(); err != nil {
t.Fatal(err)
} else {
for _, team := range teams {
if team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as false")
}
}
teams, err := ss.Team().GetAllPrivateTeamListing()
require.Nil(t, err)
require.NotEmpty(t, teams, "failed team listing")
if len(teams) == 0 {
t.Fatal("failed team listing")
}
for _, team := range teams {
require.False(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as false")
}
}
@@ -637,20 +585,14 @@ func testGetAllPrivateTeamPageListing(t *testing.T, ss store.Store) {
_, err = ss.Team().Save(&o4)
require.Nil(t, err)
if teams, listErr := ss.Team().GetAllPrivateTeamPageListing(0, 10); listErr != nil {
t.Fatal(listErr)
} else {
for _, team := range teams {
if team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as false")
}
}
if len(teams) > 10 {
t.Fatal("should have returned max of 10 teams")
}
teams, listErr := ss.Team().GetAllPrivateTeamPageListing(0, 10)
require.Nil(t, listErr)
for _, team := range teams {
require.False(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as false")
}
require.LessOrEqual(t, len(teams), 10, "should have returned max of 10 teams")
o5 := model.Team{}
o5.DisplayName = "DisplayName"
o5.Name = "z-z-z" + model.NewId() + "b"
@@ -660,33 +602,21 @@ func testGetAllPrivateTeamPageListing(t *testing.T, ss store.Store) {
_, err = ss.Team().Save(&o5)
require.Nil(t, err)
if teams, listErr := ss.Team().GetAllPrivateTeamPageListing(0, 4); listErr != nil {
t.Fatal(listErr)
} else {
for _, team := range teams {
if team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as false")
}
}
if len(teams) > 4 {
t.Fatal("should have returned max of 4 teams")
}
teams, listErr = ss.Team().GetAllPrivateTeamPageListing(0, 4)
require.Nil(t, listErr)
for _, team := range teams {
require.False(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as false")
}
if teams, listErr := ss.Team().GetAllPrivateTeamPageListing(1, 1); listErr != nil {
t.Fatal(listErr)
} else {
for _, team := range teams {
if team.AllowOpenInvite {
t.Fatal("should have returned team with AllowOpenInvite as false")
}
}
require.LessOrEqual(t, len(teams), 4, "should have returned max of 4 teams")
if len(teams) > 1 {
t.Fatal("should have returned max of 1 team")
}
teams, listErr = ss.Team().GetAllPrivateTeamPageListing(1, 1)
require.Nil(t, listErr)
for _, team := range teams {
require.False(t, team.AllowOpenInvite, "should have returned team with AllowOpenInvite as false")
}
require.LessOrEqual(t, len(teams), 1, "should have returned max of 1 team")
}
func testGetAllPublicTeamPageListing(t *testing.T, ss store.Store) {
@@ -767,9 +697,8 @@ func testDelete(t *testing.T, ss store.Store) {
_, err = ss.Team().Save(&o2)
require.Nil(t, err)
if r1 := ss.Team().PermanentDelete(o1.Id); r1 != nil {
t.Fatal(r1)
}
r1 := ss.Team().PermanentDelete(o1.Id)
require.Nil(t, r1)
}
func testPublicTeamCount(t *testing.T, ss store.Store) {
@@ -852,13 +781,9 @@ func testTeamCount(t *testing.T, ss store.Store) {
_, err := ss.Team().Save(&o1)
require.Nil(t, err)
if teamCount, err := ss.Team().AnalyticsTeamCount(); err != nil {
t.Fatal(err)
} else {
if teamCount == 0 {
t.Fatal("should be at least 1 team")
}
}
teamCount, err := ss.Team().AnalyticsTeamCount()
require.Nil(t, err)
require.NotEqual(t, 0, int(teamCount), "should be at least 1 team")
}
func testTeamMembers(t *testing.T, ss store.Store) {
@@ -880,47 +805,33 @@ func testTeamMembers(t *testing.T, ss store.Store) {
require.Nil(t, err)
assert.Len(t, ms, 2)
if ms, err = ss.Team().GetMembers(teamId2, 0, 100, nil); err != nil {
t.Fatal(err)
} else {
ms, err = ss.Team().GetMembers(teamId2, 0, 100, nil)
require.Nil(t, err)
require.Len(t, ms, 1)
require.Equal(t, m3.UserId, ms[0].UserId)
require.Len(t, ms, 1)
require.Equal(t, m3.UserId, ms[0].UserId)
}
ms, err = ss.Team().GetTeamsForUser(m1.UserId)
require.Nil(t, err)
require.Len(t, ms, 1)
require.Equal(t, m1.TeamId, ms[0].TeamId)
if ms, err = ss.Team().GetTeamsForUser(m1.UserId); err != nil {
t.Fatal(err)
} else {
err = ss.Team().RemoveMember(teamId1, m1.UserId)
require.Nil(t, err)
require.Len(t, ms, 1)
require.Equal(t, m1.TeamId, ms[0].TeamId)
}
if err = ss.Team().RemoveMember(teamId1, m1.UserId); err != nil {
t.Fatal(err)
}
if ms, err = ss.Team().GetMembers(teamId1, 0, 100, nil); err != nil {
t.Fatal(err)
} else {
require.Len(t, ms, 1)
require.Equal(t, m2.UserId, ms[0].UserId)
}
ms, err = ss.Team().GetMembers(teamId1, 0, 100, nil)
require.Nil(t, err)
require.Len(t, ms, 1)
require.Equal(t, m2.UserId, ms[0].UserId)
_, err = ss.Team().SaveMember(m1, -1)
require.Nil(t, err)
if err = ss.Team().RemoveAllMembersByTeam(teamId1); err != nil {
t.Fatal(err)
}
err = ss.Team().RemoveAllMembersByTeam(teamId1)
require.Nil(t, err)
if ms, err = ss.Team().GetMembers(teamId1, 0, 100, nil); err != nil {
t.Fatal(err)
} else {
require.Len(t, ms, 0)
}
ms, err = ss.Team().GetMembers(teamId1, 0, 100, nil)
require.Nil(t, err)
require.Len(t, ms, 0)
uid := model.NewId()
m4 := &model.TeamMember{TeamId: teamId1, UserId: uid}
@@ -930,23 +841,16 @@ func testTeamMembers(t *testing.T, ss store.Store) {
_, err = ss.Team().SaveMember(m5, -1)
require.Nil(t, err)
if ms, err = ss.Team().GetTeamsForUser(uid); err != nil {
t.Fatal(err)
} else {
ms, err = ss.Team().GetTeamsForUser(uid)
require.Nil(t, err)
require.Len(t, ms, 2)
require.Len(t, ms, 2)
}
err = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, err)
if err = ss.Team().RemoveAllMembersByUser(uid); err != nil {
t.Fatal(err)
}
if ms, err = ss.Team().GetTeamsForUser(m1.UserId); err != nil {
t.Fatal(err)
} else {
require.Len(t, ms, 0)
}
ms, err = ss.Team().GetTeamsForUser(m1.UserId)
require.Nil(t, err)
require.Len(t, ms, 0)
}
func testTeamMembersWithPagination(t *testing.T, ss store.Store) {
@@ -1044,11 +948,9 @@ func testSaveTeamMemberMaxMembers(t *testing.T, ss store.Store) {
}(userIds[i])
}
if totalMemberCount, err := ss.Team().GetTotalMemberCount(team.Id, nil); err != nil {
t.Fatal(err)
} else if int(totalMemberCount) != maxUsersPerTeam {
t.Fatalf("should start with 5 team members, had %v instead", totalMemberCount)
}
totalMemberCount, err := ss.Team().GetTotalMemberCount(team.Id, nil)
require.Nil(t, err)
require.Equal(t, int(totalMemberCount), maxUsersPerTeam, "should start with 5 team members, had %v instead", totalMemberCount)
user, err := ss.User().Save(&model.User{
Username: model.NewId(),
@@ -1060,47 +962,36 @@ func testSaveTeamMemberMaxMembers(t *testing.T, ss store.Store) {
ss.User().PermanentDelete(newUserId)
}()
if _, err = ss.Team().SaveMember(&model.TeamMember{
_, err = ss.Team().SaveMember(&model.TeamMember{
TeamId: team.Id,
UserId: newUserId,
}, maxUsersPerTeam); err == nil {
t.Fatal("shouldn't be able to save member when at maximum members per team")
}
}, maxUsersPerTeam)
require.NotNil(t, err, "shouldn't be able to save member when at maximum members per team")
if totalMemberCount, teamErr := ss.Team().GetTotalMemberCount(team.Id, nil); teamErr != nil {
t.Fatal(teamErr)
} else if int(totalMemberCount) != maxUsersPerTeam {
t.Fatalf("should still have 5 team members, had %v instead", totalMemberCount)
}
totalMemberCount, teamErr := ss.Team().GetTotalMemberCount(team.Id, nil)
require.Nil(t, teamErr)
require.Equal(t, maxUsersPerTeam, int(totalMemberCount), "should still have 5 team members, had %v instead", totalMemberCount)
// Leaving the team from the UI sets DeleteAt instead of using TeamStore.RemoveMember
if _, teamErr := ss.Team().UpdateMember(&model.TeamMember{
_, teamErr = ss.Team().UpdateMember(&model.TeamMember{
TeamId: team.Id,
UserId: userIds[0],
DeleteAt: 1234,
}); teamErr != nil {
panic(teamErr)
}
})
require.Nil(t, teamErr)
if totalMemberCount, teamErr := ss.Team().GetTotalMemberCount(team.Id, nil); teamErr != nil {
t.Fatal(teamErr)
} else if int(totalMemberCount) != maxUsersPerTeam-1 {
t.Fatalf("should now only have 4 team members, had %v instead", totalMemberCount)
}
totalMemberCount, teamErr = ss.Team().GetTotalMemberCount(team.Id, nil)
require.Nil(t, teamErr)
require.Equal(t, maxUsersPerTeam-1, int(totalMemberCount), "should now only have 4 team members, had %v instead", totalMemberCount)
if _, err = ss.Team().SaveMember(&model.TeamMember{TeamId: team.Id, UserId: newUserId}, maxUsersPerTeam); err != nil {
t.Fatal("should've been able to save new member after deleting one", err)
} else {
defer func(userId string) {
ss.Team().RemoveMember(team.Id, userId)
}(newUserId)
}
_, err = ss.Team().SaveMember(&model.TeamMember{TeamId: team.Id, UserId: newUserId}, maxUsersPerTeam)
require.Nil(t, err, "should've been able to save new member after deleting one")
if totalMemberCount, teamErr := ss.Team().GetTotalMemberCount(team.Id, nil); teamErr != nil {
t.Fatal(teamErr)
} else if int(totalMemberCount) != maxUsersPerTeam {
t.Fatalf("should have 5 team members again, had %v instead", totalMemberCount)
}
defer ss.Team().RemoveMember(team.Id, newUserId)
totalMemberCount, teamErr = ss.Team().GetTotalMemberCount(team.Id, nil)
require.Nil(t, teamErr)
require.Equal(t, maxUsersPerTeam, int(totalMemberCount), "should have 5 team members again, had %v instead", totalMemberCount)
// Deactivating a user should make them stop counting against max members
user2, err := ss.User().Get(userIds[1])
@@ -1115,13 +1006,10 @@ func testSaveTeamMemberMaxMembers(t *testing.T, ss store.Store) {
})
require.Nil(t, err)
newUserId2 := user.Id
if _, err := ss.Team().SaveMember(&model.TeamMember{TeamId: team.Id, UserId: newUserId2}, maxUsersPerTeam); err != nil {
t.Fatal("should've been able to save new member after deleting one", err)
} else {
defer func(userId string) {
ss.Team().RemoveMember(team.Id, userId)
}(newUserId2)
}
_, err = ss.Team().SaveMember(&model.TeamMember{TeamId: team.Id, UserId: newUserId2}, maxUsersPerTeam)
require.Nil(t, err, "should've been able to save new member after deleting one")
defer ss.Team().RemoveMember(team.Id, newUserId2)
}
func testGetTeamMember(t *testing.T, ss store.Store) {
@@ -1132,26 +1020,18 @@ func testGetTeamMember(t *testing.T, ss store.Store) {
require.Nil(t, err)
var rm1 *model.TeamMember
if rm1, err = ss.Team().GetMember(m1.TeamId, m1.UserId); err != nil {
t.Fatal(err)
} else {
rm1, err = ss.Team().GetMember(m1.TeamId, m1.UserId)
require.Nil(t, err)
if rm1.TeamId != m1.TeamId {
t.Fatal("bad team id")
}
require.Equal(t, rm1.TeamId, m1.TeamId, "bad team id")
if rm1.UserId != m1.UserId {
t.Fatal("bad user id")
}
}
require.Equal(t, rm1.UserId, m1.UserId, "bad user id")
if _, err = ss.Team().GetMember(m1.TeamId, ""); err == nil {
t.Fatal("empty user id - should have failed")
}
_, err = ss.Team().GetMember(m1.TeamId, "")
require.NotNil(t, err, "empty user id - should have failed")
if _, err = ss.Team().GetMember("", m1.UserId); err == nil {
t.Fatal("empty team id - should have failed")
}
_, err = ss.Team().GetMember("", m1.UserId)
require.NotNil(t, err, "empty team id - should have failed")
// Test with a custom team scheme.
s2 := &model.Scheme{
@@ -1204,36 +1084,24 @@ func testGetTeamMembersByIds(t *testing.T, ss store.Store) {
require.Nil(t, err)
var r []*model.TeamMember
if r, err = ss.Team().GetMembersByIds(m1.TeamId, []string{m1.UserId}, nil); err != nil {
t.Fatal(err)
} else {
rm1 := r[0]
r, err = ss.Team().GetMembersByIds(m1.TeamId, []string{m1.UserId}, nil)
require.Nil(t, err)
rm1 := r[0]
if rm1.TeamId != m1.TeamId {
t.Fatal("bad team id")
}
if rm1.UserId != m1.UserId {
t.Fatal("bad user id")
}
}
require.Equal(t, rm1.TeamId, m1.TeamId, "bad team id")
require.Equal(t, rm1.UserId, m1.UserId, "bad user id")
m2 := &model.TeamMember{TeamId: teamId1, UserId: model.NewId()}
_, err = ss.Team().SaveMember(m2, -1)
require.Nil(t, err)
if rm, err := ss.Team().GetMembersByIds(m1.TeamId, []string{m1.UserId, m2.UserId, model.NewId()}, nil); err != nil {
t.Fatal(err)
} else {
rm, err := ss.Team().GetMembersByIds(m1.TeamId, []string{m1.UserId, m2.UserId, model.NewId()}, nil)
require.Nil(t, err)
if len(rm) != 2 {
t.Fatal("return wrong number of results")
}
}
require.Len(t, rm, 2, "return wrong number of results")
if _, err := ss.Team().GetMembersByIds(m1.TeamId, []string{}, nil); err == nil {
t.Fatal("empty user ids - should have failed")
}
_, err = ss.Team().GetMembersByIds(m1.TeamId, []string{}, nil)
require.NotNil(t, err, "empty user ids - should have failed")
}
func testTeamStoreMemberCount(t *testing.T, ss store.Store) {
@@ -1258,42 +1126,26 @@ func testTeamStoreMemberCount(t *testing.T, ss store.Store) {
require.Nil(t, err)
var totalMemberCount int64
if totalMemberCount, err = ss.Team().GetTotalMemberCount(teamId1, nil); err != nil {
t.Fatal(err)
} else {
if totalMemberCount != 2 {
t.Fatal("wrong count")
}
}
totalMemberCount, err = ss.Team().GetTotalMemberCount(teamId1, nil)
require.Nil(t, err)
require.Equal(t, int(totalMemberCount), 2, "wrong count")
var result int64
if result, err = ss.Team().GetActiveMemberCount(teamId1, nil); err != nil {
t.Fatal(err)
} else {
if result != 1 {
t.Fatal("wrong count")
}
}
result, err = ss.Team().GetActiveMemberCount(teamId1, nil)
require.Nil(t, err)
require.Equal(t, 1, int(result), "wrong count")
m3 := &model.TeamMember{TeamId: teamId1, UserId: model.NewId()}
_, err = ss.Team().SaveMember(m3, -1)
require.Nil(t, err)
if totalMemberCount, err := ss.Team().GetTotalMemberCount(teamId1, nil); err != nil {
t.Fatal(err)
} else {
if totalMemberCount != 2 {
t.Fatal("wrong count")
}
}
totalMemberCount, err = ss.Team().GetTotalMemberCount(teamId1, nil)
require.Nil(t, err)
require.Equal(t, 2, int(totalMemberCount), "wrong count")
if result, err := ss.Team().GetActiveMemberCount(teamId1, nil); err != nil {
t.Fatal(err)
} else {
if result != 1 {
t.Fatal("wrong count")
}
}
result, err = ss.Team().GetActiveMemberCount(teamId1, nil)
require.Nil(t, err)
require.Equal(t, 1, int(result), "wrong count")
}
func testGetChannelUnreadsForAllTeams(t *testing.T, ss store.Store) {
@@ -1323,48 +1175,35 @@ func testGetChannelUnreadsForAllTeams(t *testing.T, ss store.Store) {
_, err = ss.Channel().SaveMember(cm2)
require.Nil(t, err)
if ms1, err := ss.Team().GetChannelUnreadsForAllTeams("", uid); err != nil {
t.Fatal(err)
} else {
membersMap := make(map[string]bool)
for i := range ms1 {
id := ms1[i].TeamId
if _, ok := membersMap[id]; !ok {
membersMap[id] = true
}
}
if len(membersMap) != 2 {
t.Fatal("Should be the unreads for all the teams")
ms1, err := ss.Team().GetChannelUnreadsForAllTeams("", uid)
require.Nil(t, err)
membersMap := make(map[string]bool)
for i := range ms1 {
id := ms1[i].TeamId
if _, ok := membersMap[id]; !ok {
membersMap[id] = true
}
}
require.Len(t, membersMap, 2, "Should be the unreads for all the teams")
if ms1[0].MsgCount != 10 {
t.Fatal("subtraction failed")
require.Equal(t, 10, int(ms1[0].MsgCount), "subtraction failed")
ms2, err := ss.Team().GetChannelUnreadsForAllTeams(teamId1, uid)
require.Nil(t, err)
membersMap = make(map[string]bool)
for i := range ms2 {
id := ms2[i].TeamId
if _, ok := membersMap[id]; !ok {
membersMap[id] = true
}
}
if ms2, err := ss.Team().GetChannelUnreadsForAllTeams(teamId1, uid); err != nil {
t.Fatal(err)
} else {
membersMap := make(map[string]bool)
for i := range ms2 {
id := ms2[i].TeamId
if _, ok := membersMap[id]; !ok {
membersMap[id] = true
}
}
require.Len(t, membersMap, 1, "Should be the unreads for just one team")
if len(membersMap) != 1 {
t.Fatal("Should be the unreads for just one team")
}
require.Equal(t, 10, int(ms2[0].MsgCount), "subtraction failed")
if ms2[0].MsgCount != 10 {
t.Fatal("subtraction failed")
}
}
if err := ss.Team().RemoveAllMembersByUser(uid); err != nil {
t.Fatal(err)
}
err = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, err)
}
func testGetChannelUnreadsForTeam(t *testing.T, ss store.Store) {
@@ -1390,17 +1229,11 @@ func testGetChannelUnreadsForTeam(t *testing.T, ss store.Store) {
_, err = ss.Channel().SaveMember(cm2)
require.Nil(t, err)
if ms, err := ss.Team().GetChannelUnreadsForTeam(m1.TeamId, m1.UserId); err != nil {
t.Fatal(err)
} else {
if len(ms) != 2 {
t.Fatal("wrong length")
}
ms, err := ss.Team().GetChannelUnreadsForTeam(m1.TeamId, m1.UserId)
require.Nil(t, err)
require.Len(t, ms, 2, "wrong length")
if ms[0].MsgCount != 10 {
t.Fatal("subtraction failed")
}
}
require.Equal(t, 10, int(ms[0].MsgCount), "subtraction failed")
}
func testUpdateLastTeamIconUpdate(t *testing.T, ss store.Store) {
@@ -1419,16 +1252,13 @@ func testUpdateLastTeamIconUpdate(t *testing.T, ss store.Store) {
curTime := model.GetMillis()
if err = ss.Team().UpdateLastTeamIconUpdate(o1.Id, curTime); err != nil {
t.Fatal(err)
}
err = ss.Team().UpdateLastTeamIconUpdate(o1.Id, curTime)
require.Nil(t, err)
ro1, err := ss.Team().Get(o1.Id)
require.Nil(t, err)
if ro1.LastTeamIconUpdate <= lastTeamIconUpdateInitial {
t.Fatal("LastTeamIconUpdate not updated")
}
require.Greater(t, ro1.LastTeamIconUpdate, lastTeamIconUpdateInitial, "LastTeamIconUpdate not updated")
}
func testGetTeamsByScheme(t *testing.T, ss store.Store) {

337
store/storetest/webhook_store.go
Просмотреть файл

@@ -43,13 +43,11 @@ func TestWebhookStore(t *testing.T, ss store.Store) {
func testWebhookStoreSaveIncoming(t *testing.T, ss store.Store) {
o1 := buildIncomingWebhook()
if _, err := ss.Webhook().SaveIncoming(o1); err != nil {
t.Fatal("couldn't save item", err)
}
_, err := ss.Webhook().SaveIncoming(o1)
require.Nil(t, err, "couldn't save item")
if _, err := ss.Webhook().SaveIncoming(o1); err == nil {
t.Fatal("shouldn't be able to update from save")
}
_, err = ss.Webhook().SaveIncoming(o1)
require.NotNil(t, err, "shouldn't be able to update from save")
}
func testWebhookStoreUpdateIncoming(t *testing.T, ss store.Store) {
@@ -58,9 +56,7 @@ func testWebhookStoreUpdateIncoming(t *testing.T, ss store.Store) {
o1 := buildIncomingWebhook()
o1, err = ss.Webhook().SaveIncoming(o1)
if err != nil {
t.Fatal("unable to save webhook", err)
}
require.Nil(t, err, "unable to save webhook")
previousUpdatedAt := o1.UpdateAt
@@ -70,14 +66,9 @@ func testWebhookStoreUpdateIncoming(t *testing.T, ss store.Store) {
webhook, err := ss.Webhook().UpdateIncoming(o1)
require.Nil(t, err)
if webhook.UpdateAt == previousUpdatedAt {
t.Fatal("should have updated the UpdatedAt of the hook")
}
if webhook.DisplayName != "TestHook" {
t.Fatal("display name is not updated")
}
require.NotEqual(t, webhook.UpdateAt, previousUpdatedAt, "should have updated the UpdatedAt of the hook")
require.Equal(t, "TestHook", webhook.DisplayName, "display name is not updated")
}
func testWebhookStoreGetIncoming(t *testing.T, ss store.Store) {
@@ -85,33 +76,25 @@ func testWebhookStoreGetIncoming(t *testing.T, ss store.Store) {
o1 := buildIncomingWebhook()
o1, err = ss.Webhook().SaveIncoming(o1)
if err != nil {
t.Fatal("unable to save webhook", err)
}
require.Nil(t, err, "unable to save webhook")
webhook, err := ss.Webhook().GetIncoming(o1.Id, false)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
webhook, err = ss.Webhook().GetIncoming(o1.Id, true)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if _, err = ss.Webhook().GetIncoming("123", false); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetIncoming("123", false)
require.NotNil(t, err, "Missing id should have failed")
if _, err = ss.Webhook().GetIncoming("123", true); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetIncoming("123", true)
require.NotNil(t, err, "Missing id should have failed")
if _, err = ss.Webhook().GetIncoming("123", true); err.StatusCode != http.StatusNotFound {
t.Fatal("Should have set the status as not found for missing id")
}
_, err = ss.Webhook().GetIncoming("123", true)
require.NotNil(t, err)
require.Equal(t, err.StatusCode, http.StatusNotFound, "Should have set the status as not found for missing id")
}
func testWebhookStoreGetIncomingList(t *testing.T, ss store.Store) {
@@ -122,31 +105,22 @@ func testWebhookStoreGetIncomingList(t *testing.T, ss store.Store) {
var err *model.AppError
o1, err = ss.Webhook().SaveIncoming(o1)
if err != nil {
t.Fatal("unable to save webhook", err)
}
require.Nil(t, err, "unable to save webhook")
if hooks, err := ss.Webhook().GetIncomingList(0, 1000); err != nil {
t.Fatal(err)
} else {
found := false
for _, hook := range hooks {
if hook.Id == o1.Id {
found = true
}
}
if !found {
t.Fatal("missing webhook")
}
}
hooks, err := ss.Webhook().GetIncomingList(0, 1000)
require.Nil(t, err)
if hooks, err := ss.Webhook().GetIncomingList(0, 1); err != nil {
t.Fatal(err)
} else {
if len(hooks) != 1 {
t.Fatal("only 1 should be returned")
found := false
for _, hook := range hooks {
if hook.Id == o1.Id {
found = true
}
}
require.True(t, found, "missing webhook")
hooks, err = ss.Webhook().GetIncomingList(0, 1)
require.Nil(t, err)
require.Len(t, hooks, 1, "only 1 should be returned")
}
func testWebhookStoreGetIncomingListByUser(t *testing.T, ss store.Store) {
@@ -179,21 +153,13 @@ func testWebhookStoreGetIncomingByTeam(t *testing.T, ss store.Store) {
o1, err = ss.Webhook().SaveIncoming(o1)
require.Nil(t, err)
if hooks, err := ss.Webhook().GetIncomingByTeam(o1.TeamId, 0, 100); err != nil {
t.Fatal(err)
} else {
if hooks[0].CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
}
hooks, err := ss.Webhook().GetIncomingByTeam(o1.TeamId, 0, 100)
require.Nil(t, err)
require.Equal(t, hooks[0].CreateAt, o1.CreateAt, "invalid returned webhook")
if hooks, err := ss.Webhook().GetIncomingByTeam("123", 0, 100); err != nil {
t.Fatal(err)
} else {
if len(hooks) != 0 {
t.Fatal("no webhooks should have returned")
}
}
hooks, err = ss.Webhook().GetIncomingByTeam("123", 0, 100)
require.Nil(t, err)
require.Len(t, hooks, 0, "no webhooks should have returned")
}
func TestWebhookStoreGetIncomingByTeamByUser(t *testing.T, ss store.Store) {
@@ -232,23 +198,15 @@ func TestWebhookStoreGetIncomingByChannel(t *testing.T, ss store.Store) {
o1 := buildIncomingWebhook()
o1, err := ss.Webhook().SaveIncoming(o1)
if err != nil {
t.Fatal("unable to save webhook")
}
require.Nil(t, err, "unable to save webhook")
webhooks, err := ss.Webhook().GetIncomingByChannel(o1.ChannelId)
require.Nil(t, err)
if webhooks[0].CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhooks[0].CreateAt, o1.CreateAt, "invalid returned webhook")
if webhooks, err = ss.Webhook().GetIncomingByChannel("123"); err != nil {
t.Fatal(err)
} else {
if len(webhooks) != 0 {
t.Fatal("no webhooks should have returned")
}
}
webhooks, err = ss.Webhook().GetIncomingByChannel("123")
require.Nil(t, err)
require.Len(t, webhooks, 0, "no webhooks should have returned")
}
func testWebhookStoreDeleteIncoming(t *testing.T, ss store.Store) {
@@ -256,19 +214,14 @@ func testWebhookStoreDeleteIncoming(t *testing.T, ss store.Store) {
o1 := buildIncomingWebhook()
o1, err = ss.Webhook().SaveIncoming(o1)
if err != nil {
t.Fatal("unable to save webhook", err)
}
require.Nil(t, err, "unable to save webhook")
webhook, err := ss.Webhook().GetIncoming(o1.Id, true)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if err = ss.Webhook().DeleteIncoming(o1.Id, model.GetMillis()); err != nil {
t.Fatal(err)
}
err = ss.Webhook().DeleteIncoming(o1.Id, model.GetMillis())
require.Nil(t, err)
webhook, err = ss.Webhook().GetIncoming(o1.Id, true)
require.NotNil(t, err)
@@ -279,23 +232,17 @@ func testWebhookStoreDeleteIncomingByChannel(t *testing.T, ss store.Store) {
o1 := buildIncomingWebhook()
o1, err = ss.Webhook().SaveIncoming(o1)
if err != nil {
t.Fatal("unable to save webhook", err)
}
require.Nil(t, err, "unable to save webhook")
webhook, err := ss.Webhook().GetIncoming(o1.Id, true)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if err = ss.Webhook().PermanentDeleteIncomingByChannel(o1.ChannelId); err != nil {
t.Fatal(err)
}
err = ss.Webhook().PermanentDeleteIncomingByChannel(o1.ChannelId)
require.Nil(t, err)
if _, err = ss.Webhook().GetIncoming(o1.Id, true); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetIncoming(o1.Id, true)
require.NotNil(t, err, "Missing id should have failed")
}
func testWebhookStoreDeleteIncomingByUser(t *testing.T, ss store.Store) {
@@ -303,23 +250,17 @@ func testWebhookStoreDeleteIncomingByUser(t *testing.T, ss store.Store) {
o1 := buildIncomingWebhook()
o1, err = ss.Webhook().SaveIncoming(o1)
if err != nil {
t.Fatal("unable to save webhook", err)
}
require.Nil(t, err, "unable to save webhook")
webhook, err := ss.Webhook().GetIncoming(o1.Id, true)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if err = ss.Webhook().PermanentDeleteIncomingByUser(o1.UserId); err != nil {
t.Fatal(err)
}
err = ss.Webhook().PermanentDeleteIncomingByUser(o1.UserId)
require.Nil(t, err)
if _, err = ss.Webhook().GetIncoming(o1.Id, true); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetIncoming(o1.Id, true)
require.NotNil(t, err, "Missing id should have failed")
}
func buildIncomingWebhook() *model.IncomingWebhook {
@@ -340,13 +281,11 @@ func testWebhookStoreSaveOutgoing(t *testing.T, ss store.Store) {
o1.Username = "test-user-name"
o1.IconURL = "http://nowhere.com/icon"
if _, err := ss.Webhook().SaveOutgoing(&o1); err != nil {
t.Fatal("couldn't save item", err)
}
_, err := ss.Webhook().SaveOutgoing(&o1)
require.Nil(t, err, "couldn't save item")
if _, err := ss.Webhook().SaveOutgoing(&o1); err == nil {
t.Fatal("shouldn't be able to update from save")
}
_, err = ss.Webhook().SaveOutgoing(&o1)
require.NotNil(t, err, "shouldn't be able to update from save")
}
func testWebhookStoreGetOutgoing(t *testing.T, ss store.Store) {
@@ -362,13 +301,10 @@ func testWebhookStoreGetOutgoing(t *testing.T, ss store.Store) {
webhook, err := ss.Webhook().GetOutgoing(o1.Id)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if _, err := ss.Webhook().GetOutgoing("123"); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetOutgoing("123")
require.NotNil(t, err, "Missing id should have failed")
}
func testWebhookStoreGetOutgoingListByUser(t *testing.T, ss store.Store) {
@@ -412,38 +348,28 @@ func testWebhookStoreGetOutgoingList(t *testing.T, ss store.Store) {
o2, _ = ss.Webhook().SaveOutgoing(o2)
if r1, err := ss.Webhook().GetOutgoingList(0, 1000); err != nil {
t.Fatal(err)
} else {
hooks := r1
found1 := false
found2 := false
r1, err := ss.Webhook().GetOutgoingList(0, 1000)
require.Nil(t, err)
hooks := r1
found1 := false
found2 := false
for _, hook := range hooks {
if hook.CreateAt != o1.CreateAt {
found1 = true
}
if hook.CreateAt != o2.CreateAt {
found2 = true
}
for _, hook := range hooks {
if hook.CreateAt != o1.CreateAt {
found1 = true
}
if !found1 {
t.Fatal("missing hook1")
}
if !found2 {
t.Fatal("missing hook2")
if hook.CreateAt != o2.CreateAt {
found2 = true
}
}
if result, err := ss.Webhook().GetOutgoingList(0, 2); err != nil {
t.Fatal(err)
} else {
if len(result) != 2 {
t.Fatal("wrong number of hooks returned")
}
}
require.True(t, found1, "missing hook1")
require.True(t, found2, "missing hook2")
result, err := ss.Webhook().GetOutgoingList(0, 2)
require.Nil(t, err)
require.Len(t, result, 2, "wrong number of hooks returned")
}
func testWebhookStoreGetOutgoingByChannel(t *testing.T, ss store.Store) {
@@ -455,21 +381,13 @@ func testWebhookStoreGetOutgoingByChannel(t *testing.T, ss store.Store) {
o1, _ = ss.Webhook().SaveOutgoing(o1)
if r1, err := ss.Webhook().GetOutgoingByChannel(o1.ChannelId, 0, 100); err != nil {
t.Fatal(err)
} else {
if r1[0].CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
}
r1, err := ss.Webhook().GetOutgoingByChannel(o1.ChannelId, 0, 100)
require.Nil(t, err)
require.Equal(t, r1[0].CreateAt, o1.CreateAt, "invalid returned webhook")
if result, err := ss.Webhook().GetOutgoingByChannel("123", -1, -1); err != nil {
t.Fatal(err)
} else {
if len(result) != 0 {
t.Fatal("no webhooks should have returned")
}
}
result, err := ss.Webhook().GetOutgoingByChannel("123", -1, -1)
require.Nil(t, err)
require.Len(t, result, 0, "no webhooks should have returned")
}
func testWebhookStoreGetOutgoingByChannelByUser(t *testing.T, ss store.Store) {
@@ -520,21 +438,13 @@ func testWebhookStoreGetOutgoingByTeam(t *testing.T, ss store.Store) {
o1, _ = ss.Webhook().SaveOutgoing(o1)
if r1, err := ss.Webhook().GetOutgoingByTeam(o1.TeamId, 0, 100); err != nil {
t.Fatal(err)
} else {
if r1[0].CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
}
r1, err := ss.Webhook().GetOutgoingByTeam(o1.TeamId, 0, 100)
require.Nil(t, err)
require.Equal(t, r1[0].CreateAt, o1.CreateAt, "invalid returned webhook")
if result, err := ss.Webhook().GetOutgoingByTeam("123", -1, -1); err != nil {
t.Fatal(err)
} else {
if len(result) != 0 {
t.Fatal("no webhooks should have returned")
}
}
result, err := ss.Webhook().GetOutgoingByTeam("123", -1, -1)
require.Nil(t, err)
require.Len(t, result, 0, "no webhooks should have returned")
}
func testWebhookStoreGetOutgoingByTeamByUser(t *testing.T, ss store.Store) {
@@ -589,17 +499,13 @@ func testWebhookStoreDeleteOutgoing(t *testing.T, ss store.Store) {
webhook, err := ss.Webhook().GetOutgoing(o1.Id)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if err := ss.Webhook().DeleteOutgoing(o1.Id, model.GetMillis()); err != nil {
t.Fatal(err)
}
err = ss.Webhook().DeleteOutgoing(o1.Id, model.GetMillis())
require.Nil(t, err)
if _, err := ss.Webhook().GetOutgoing(o1.Id); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetOutgoing(o1.Id)
require.NotNil(t, err, "Missing id should have failed")
}
func testWebhookStoreDeleteOutgoingByChannel(t *testing.T, ss store.Store) {
@@ -613,17 +519,13 @@ func testWebhookStoreDeleteOutgoingByChannel(t *testing.T, ss store.Store) {
webhook, err := ss.Webhook().GetOutgoing(o1.Id)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if err := ss.Webhook().PermanentDeleteOutgoingByChannel(o1.ChannelId); err != nil {
t.Fatal(err)
}
err = ss.Webhook().PermanentDeleteOutgoingByChannel(o1.ChannelId)
require.Nil(t, err)
if _, err := ss.Webhook().GetOutgoing(o1.Id); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetOutgoing(o1.Id)
require.NotNil(t, err, "Missing id should have failed")
}
func testWebhookStoreDeleteOutgoingByUser(t *testing.T, ss store.Store) {
@@ -637,17 +539,13 @@ func testWebhookStoreDeleteOutgoingByUser(t *testing.T, ss store.Store) {
webhook, err := ss.Webhook().GetOutgoing(o1.Id)
require.Nil(t, err)
if webhook.CreateAt != o1.CreateAt {
t.Fatal("invalid returned webhook")
}
require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
if err := ss.Webhook().PermanentDeleteOutgoingByUser(o1.CreatorId); err != nil {
t.Fatal(err)
}
err = ss.Webhook().PermanentDeleteOutgoingByUser(o1.CreatorId)
require.Nil(t, err)
if _, err := ss.Webhook().GetOutgoing(o1.Id); err == nil {
t.Fatal("Missing id should have failed")
}
_, err = ss.Webhook().GetOutgoing(o1.Id)
require.NotNil(t, err, "Missing id should have failed")
}
func testWebhookStoreUpdateOutgoing(t *testing.T, ss store.Store) {
@@ -664,9 +562,8 @@ func testWebhookStoreUpdateOutgoing(t *testing.T, ss store.Store) {
o1.Token = model.NewId()
o1.Username = "another-test-user-name"
if _, err := ss.Webhook().UpdateOutgoing(o1); err != nil {
t.Fatal(err)
}
_, err := ss.Webhook().UpdateOutgoing(o1)
require.Nil(t, err)
}
func testWebhookStoreCountIncoming(t *testing.T, ss store.Store) {
@@ -678,13 +575,9 @@ func testWebhookStoreCountIncoming(t *testing.T, ss store.Store) {
_, _ = ss.Webhook().SaveIncoming(o1)
c, err := ss.Webhook().AnalyticsIncomingCount("")
if err != nil {
t.Fatal(err)
}
require.Nil(t, err)
if c == 0 {
t.Fatal("should have at least 1 incoming hook")
}
require.NotEqual(t, 0, c, "should have at least 1 incoming hook")
}
func testWebhookStoreCountOutgoing(t *testing.T, ss store.Store) {
@@ -696,11 +589,7 @@ func testWebhookStoreCountOutgoing(t *testing.T, ss store.Store) {
ss.Webhook().SaveOutgoing(o1)
if r, err := ss.Webhook().AnalyticsOutgoingCount(""); err != nil {
t.Fatal(err)
} else {
if r == 0 {
t.Fatal("should have at least 1 outgoing hook")
}
}
r, err := ss.Webhook().AnalyticsOutgoingCount("")
require.Nil(t, err)
require.NotEqual(t, 0, r, "should have at least 1 outgoing hook")
}