mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
Doug LauderandGitHub
078f6b31b5
The new TestRegisterPluginForSharedChannels tests added in #36126 broke master CI because RegisterPluginForSharedChannels assigned opts.Displayname directly to RemoteCluster.Name, which IsValid validates against the slug regex ^[a-zA-Z0-9.\-_]+$. Display names with spaces (e.g. "legacy plugin") fail validation. The tests didn't run in the PR's final CI shard and the issue surfaced post-merge. Add CleanRemoteName to the public model, mirroring CleanTeamName and CleanUsername: lowercase, replace spaces and other disallowed characters with hyphens, trim, truncate to RemoteNameMaxLength, fall back to NewId when the result is empty. Use it in RegisterPluginForSharedChannels so Name is always slug-valid while DisplayName keeps the human-readable label. This also lets real plugins register with display names containing spaces.
302 lines
10 KiB
Go
302 lines
10 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package model
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestRemoteClusterIsValid(t *testing.T) {
|
|
id := NewId()
|
|
creator := NewId()
|
|
now := GetMillis()
|
|
data := []struct {
|
|
name string
|
|
rc *RemoteCluster
|
|
valid bool
|
|
}{
|
|
{name: "Zero value", rc: &RemoteCluster{}, valid: false},
|
|
{name: "Missing cluster_name", rc: &RemoteCluster{RemoteId: id}, valid: false},
|
|
{name: "Missing host_name", rc: &RemoteCluster{RemoteId: id, Name: NewId()}, valid: false},
|
|
{name: "Missing site_url", rc: &RemoteCluster{RemoteId: id, Name: NewId(), CreatorId: creator, CreateAt: now}, valid: false},
|
|
{name: "Missing create_at", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "example.com"}, valid: false},
|
|
{name: "Missing last_ping_at", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "example.com", CreatorId: creator, CreateAt: now}, valid: true},
|
|
{name: "Missing creator", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "example.com", CreateAt: now, LastPingAt: now}, valid: false},
|
|
{name: "Bad default_team_id", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "example.com", CreateAt: now, LastPingAt: now, CreatorId: creator, DefaultTeamId: "bad-id"}, valid: false},
|
|
{name: "Valid default_team_id", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "example.com", CreateAt: now, LastPingAt: now, CreatorId: creator, DefaultTeamId: NewId()}, valid: true},
|
|
{name: "RemoteCluster valid", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "example.com", CreateAt: now, LastPingAt: now, CreatorId: creator}, valid: true},
|
|
{name: "Include protocol", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "http://example.com", CreateAt: now, LastPingAt: now, CreatorId: creator}, valid: true},
|
|
{name: "Include protocol & port", rc: &RemoteCluster{RemoteId: id, Name: NewId(), SiteURL: "http://example.com:8065", CreateAt: now, LastPingAt: now, CreatorId: creator}, valid: true},
|
|
}
|
|
|
|
for _, item := range data {
|
|
appErr := item.rc.IsValid()
|
|
if item.valid {
|
|
assert.Nil(t, appErr, item.name)
|
|
} else {
|
|
assert.NotNil(t, appErr, item.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRemoteClusterPreSave(t *testing.T) {
|
|
now := GetMillis()
|
|
|
|
o := RemoteCluster{RemoteId: NewId(), Name: NewId()}
|
|
o.PreSave()
|
|
|
|
require.GreaterOrEqual(t, o.CreateAt, now)
|
|
}
|
|
|
|
func TestRemoteClusterMsgIsValid(t *testing.T) {
|
|
id := NewId()
|
|
now := GetMillis()
|
|
data := []struct {
|
|
name string
|
|
msg *RemoteClusterMsg
|
|
valid bool
|
|
}{
|
|
{name: "Zero value", msg: &RemoteClusterMsg{}, valid: false},
|
|
{name: "Missing remote id", msg: &RemoteClusterMsg{Id: id}, valid: false},
|
|
{name: "Missing Topic", msg: &RemoteClusterMsg{Id: id}, valid: false},
|
|
{name: "Missing Payload", msg: &RemoteClusterMsg{Id: id, CreateAt: now, Topic: "shared_channel"}, valid: false},
|
|
{name: "RemoteClusterMsg valid", msg: &RemoteClusterMsg{Id: id, CreateAt: now, Topic: "shared_channel", Payload: []byte("{\"hello\":\"world\"}")}, valid: true},
|
|
}
|
|
|
|
for _, item := range data {
|
|
appErr := item.msg.IsValid()
|
|
if item.valid {
|
|
assert.Nil(t, appErr, item.name)
|
|
} else {
|
|
assert.NotNil(t, appErr, item.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRemoteClusterInviteIsValid(t *testing.T) {
|
|
id := NewId()
|
|
url := "https://localhost:8080/test"
|
|
token := NewId()
|
|
|
|
data := []struct {
|
|
name string
|
|
invite *RemoteClusterInvite
|
|
valid bool
|
|
}{
|
|
{name: "Zero value", invite: &RemoteClusterInvite{}, valid: false},
|
|
{name: "Missing remote id", invite: &RemoteClusterInvite{Token: token, SiteURL: url}, valid: false},
|
|
{name: "Missing site url", invite: &RemoteClusterInvite{RemoteId: id, Token: token}, valid: false},
|
|
{name: "Bad site url", invite: &RemoteClusterInvite{RemoteId: id, Token: token, SiteURL: ":/localhost"}, valid: false},
|
|
{name: "Missing token", invite: &RemoteClusterInvite{RemoteId: id, SiteURL: url}, valid: false},
|
|
{name: "RemoteClusterInvite valid", invite: &RemoteClusterInvite{RemoteId: id, Token: token, SiteURL: url}, valid: true},
|
|
}
|
|
|
|
for _, item := range data {
|
|
appErr := item.invite.IsValid()
|
|
if item.valid {
|
|
assert.Nil(t, appErr, item.name)
|
|
} else {
|
|
assert.NotNil(t, appErr, item.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFixTopics(t *testing.T) {
|
|
testData := []struct {
|
|
topics string
|
|
expected string
|
|
}{
|
|
{topics: "", expected: ""},
|
|
{topics: " ", expected: ""},
|
|
{topics: "share", expected: " share "},
|
|
{topics: "share incident", expected: " share incident "},
|
|
{topics: " share incident ", expected: " share incident "},
|
|
{topics: " share incident ", expected: " share incident "},
|
|
}
|
|
|
|
for _, tt := range testData {
|
|
rc := &RemoteCluster{Topics: tt.topics}
|
|
rc.fixTopics()
|
|
assert.Equal(t, tt.expected, rc.Topics)
|
|
}
|
|
}
|
|
|
|
func TestRemoteClusterInviteEncryption(t *testing.T) {
|
|
testData := []struct {
|
|
name string
|
|
badDecrypt bool
|
|
password string
|
|
invite RemoteClusterInvite
|
|
skipFIPS bool
|
|
}{
|
|
{name: "empty password", badDecrypt: false, password: "", invite: makeInvite("https://example.com:8065"), skipFIPS: true},
|
|
{name: "good password", badDecrypt: false, password: "Ultra secret password!", invite: makeInvite("https://example.com:8065")},
|
|
{name: "bad decrypt", badDecrypt: true, password: "correct horse battery staple", invite: makeInvite("https://example.com:8065")},
|
|
}
|
|
|
|
for _, tt := range testData {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if tt.skipFIPS && FIPSEnabled {
|
|
t.Skip("skipping under FIPS: encryption requires keys >= 14 bytes")
|
|
}
|
|
encrypted, err := tt.invite.Encrypt(tt.password)
|
|
require.NoError(t, err)
|
|
|
|
invite := RemoteClusterInvite{}
|
|
if tt.badDecrypt {
|
|
buf := make([]byte, len(encrypted))
|
|
_, err = io.ReadFull(rand.Reader, buf)
|
|
assert.NoError(t, err)
|
|
|
|
err = invite.Decrypt(buf, tt.password)
|
|
require.Error(t, err)
|
|
} else {
|
|
err = invite.Decrypt(encrypted, tt.password)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tt.invite, invite)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRemoteClusterInviteBackwardCompatibility(t *testing.T) {
|
|
// Test that we can decrypt invites created with the old scrypt method
|
|
oldInvite := RemoteClusterInvite{
|
|
RemoteId: NewId(),
|
|
SiteURL: "https://example.com:8065",
|
|
Token: NewId(),
|
|
RefreshedToken: NewId(),
|
|
Version: 2, // Old version using scrypt
|
|
}
|
|
|
|
password := NewTestPassword()
|
|
|
|
// Encrypt with old method (scrypt)
|
|
encrypted, err := oldInvite.Encrypt(password)
|
|
require.NoError(t, err)
|
|
|
|
// Decrypt should work with backward compatibility
|
|
decryptedInvite := RemoteClusterInvite{}
|
|
err = decryptedInvite.Decrypt(encrypted, password)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, oldInvite, decryptedInvite)
|
|
|
|
// Test new version (PBKDF2)
|
|
newInvite := RemoteClusterInvite{
|
|
RemoteId: NewId(),
|
|
SiteURL: "https://example.com:8065",
|
|
Token: NewId(),
|
|
RefreshedToken: NewId(),
|
|
Version: 3, // New version using PBKDF2
|
|
}
|
|
|
|
// Encrypt with new method (PBKDF2)
|
|
encrypted, err = newInvite.Encrypt(password)
|
|
require.NoError(t, err)
|
|
|
|
// Decrypt should work
|
|
decryptedInvite = RemoteClusterInvite{}
|
|
err = decryptedInvite.Decrypt(encrypted, password)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, newInvite, decryptedInvite)
|
|
}
|
|
|
|
func makeInvite(url string) RemoteClusterInvite {
|
|
return RemoteClusterInvite{
|
|
RemoteId: NewId(),
|
|
SiteURL: url,
|
|
Token: NewId(),
|
|
RefreshedToken: NewId(),
|
|
Version: 3,
|
|
}
|
|
}
|
|
|
|
func TestRemoteClusterToRemoteClusterInfo(t *testing.T) {
|
|
remoteID := NewId()
|
|
now := GetMillis()
|
|
rc := &RemoteCluster{
|
|
RemoteId: remoteID,
|
|
Name: "test-name",
|
|
DisplayName: "Test Display Name",
|
|
CreateAt: now,
|
|
DeleteAt: 0,
|
|
LastPingAt: now,
|
|
SiteURL: "https://example.com:8065",
|
|
}
|
|
|
|
info := rc.ToRemoteClusterInfo()
|
|
|
|
assert.Equal(t, remoteID, info.RemoteId, "RemoteId should be set")
|
|
assert.Equal(t, rc.Name, info.Name)
|
|
assert.Equal(t, rc.DisplayName, info.DisplayName)
|
|
assert.Equal(t, rc.CreateAt, info.CreateAt)
|
|
assert.Equal(t, rc.DeleteAt, info.DeleteAt)
|
|
assert.Equal(t, rc.LastPingAt, info.LastPingAt)
|
|
assert.Equal(t, rc.SiteURL, info.SiteURL)
|
|
}
|
|
|
|
func TestRemoteClusterIsPlugin(t *testing.T) {
|
|
t.Run("PluginID set returns true", func(t *testing.T) {
|
|
rc := &RemoteCluster{PluginID: "com.example.plugin", SiteURL: "https://example.com"}
|
|
assert.True(t, rc.IsPlugin())
|
|
})
|
|
|
|
t.Run("empty PluginID returns false", func(t *testing.T) {
|
|
rc := &RemoteCluster{SiteURL: "https://example.com"}
|
|
assert.False(t, rc.IsPlugin())
|
|
})
|
|
|
|
t.Run("plugin_ SiteURL prefix with empty PluginID returns false", func(t *testing.T) {
|
|
rc := &RemoteCluster{SiteURL: SiteURLPlugin + "com.example.plugin"}
|
|
assert.False(t, rc.IsPlugin(), "IsPlugin should only check PluginID, not SiteURL prefix")
|
|
})
|
|
}
|
|
|
|
func TestCleanRemoteName(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "single space", in: "legacy plugin", want: "legacy-plugin"},
|
|
{name: "multiple spaces", in: "remote 1 plugin", want: "remote-1-plugin"},
|
|
{name: "uppercase", in: "Plugin A", want: "plugin-a"},
|
|
{name: "preserves dot, hyphen, underscore", in: "com.example_plugin-1", want: "com.example_plugin-1"},
|
|
{name: "trims separators", in: " ---my remote--- ", want: "my-remote"},
|
|
{name: "punctuation collapses", in: "plugin@home!", want: "plugin-home"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got := CleanRemoteName(tc.in)
|
|
assert.Equal(t, tc.want, got)
|
|
assert.True(t, IsValidRemoteName(got), "CleanRemoteName must produce a valid name")
|
|
})
|
|
}
|
|
|
|
t.Run("empty input falls back to NewId", func(t *testing.T) {
|
|
got := CleanRemoteName("")
|
|
assert.True(t, IsValidRemoteName(got))
|
|
assert.Len(t, got, 26)
|
|
})
|
|
|
|
t.Run("only invalid characters falls back to NewId", func(t *testing.T) {
|
|
got := CleanRemoteName("@@@ !!! ???")
|
|
assert.True(t, IsValidRemoteName(got))
|
|
assert.Len(t, got, 26)
|
|
})
|
|
|
|
t.Run("over-length input is truncated", func(t *testing.T) {
|
|
in := strings.Repeat("a", RemoteNameMaxLength+10)
|
|
got := CleanRemoteName(in)
|
|
assert.True(t, IsValidRemoteName(got))
|
|
assert.LessOrEqual(t, len(got), RemoteNameMaxLength)
|
|
})
|
|
}
|