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>
911 lines
22 KiB
Go
911 lines
22 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package model
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
func TestIsValid(t *testing.T) {
|
|
testCases := []struct {
|
|
Title string
|
|
manifest *Manifest
|
|
ExpectError bool
|
|
}{
|
|
{"Invalid Id", &Manifest{Id: "some id", Name: "some name"}, true},
|
|
{"Invalid Name", &Manifest{Id: "com.company.test", Name: " "}, true},
|
|
{"Invalid homePageURL", &Manifest{Id: "com.company.test", Name: "some name", HomepageURL: "some url"}, true},
|
|
{"Invalid supportURL", &Manifest{Id: "com.company.test", Name: "some name", SupportURL: "some url"}, true},
|
|
{"Invalid ReleaseNotesURL", &Manifest{Id: "com.company.test", Name: "some name", ReleaseNotesURL: "some url"}, true},
|
|
{"Invalid version", &Manifest{Id: "com.company.test", Name: "some name", HomepageURL: "http://someurl.com", SupportURL: "http://someotherurl.com", Version: "version"}, true},
|
|
{"Invalid min version", &Manifest{Id: "com.company.test", Name: "some name", HomepageURL: "http://someurl.com", SupportURL: "http://someotherurl.com", Version: "5.10.0", MinServerVersion: "version"}, true},
|
|
{"SettingSchema error", &Manifest{Id: "com.company.test", Name: "some name", HomepageURL: "http://someurl.com", SupportURL: "http://someotherurl.com", Version: "5.10.0", MinServerVersion: "5.10.8", SettingsSchema: &PluginSettingsSchema{
|
|
Settings: []*PluginSetting{{Type: "Invalid"}},
|
|
}}, true},
|
|
{"Minimal valid manifest", &Manifest{Id: "com.company.test", Name: "some name"}, false},
|
|
{"Happy case", &Manifest{
|
|
Id: "com.company.test",
|
|
Name: "thename",
|
|
Description: "thedescription",
|
|
HomepageURL: "http://someurl.com",
|
|
SupportURL: "http://someotherurl.com",
|
|
ReleaseNotesURL: "http://someotherurl.com/releases/v0.0.1",
|
|
Version: "0.0.1",
|
|
MinServerVersion: "5.6.0",
|
|
Server: &ManifestServer{
|
|
Executable: "theexecutable",
|
|
},
|
|
Webapp: &ManifestWebapp{
|
|
BundlePath: "thebundlepath",
|
|
},
|
|
SettingsSchema: &PluginSettingsSchema{
|
|
Header: "theheadertext",
|
|
Footer: "thefootertext",
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Key: "thesetting",
|
|
DisplayName: "thedisplayname",
|
|
Type: "dropdown",
|
|
HelpText: "thehelptext",
|
|
Options: []*PluginOption{
|
|
{
|
|
DisplayName: "theoptiondisplayname",
|
|
Value: "thevalue",
|
|
},
|
|
},
|
|
Default: "thedefault",
|
|
},
|
|
},
|
|
Sections: []*PluginSettingsSection{
|
|
{
|
|
Key: "section1",
|
|
Title: "section title",
|
|
Subtitle: "section subtitle",
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Key: "section1setting1",
|
|
DisplayName: "thedisplayname",
|
|
Type: "custom",
|
|
},
|
|
{
|
|
Key: "section1setting2",
|
|
DisplayName: "thedisplayname",
|
|
Type: "custom",
|
|
},
|
|
},
|
|
Header: "section header",
|
|
Footer: "section footer",
|
|
},
|
|
{
|
|
Key: "section2",
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Key: "section2setting1",
|
|
DisplayName: "thedisplayname",
|
|
Type: "custom",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Key: "section3",
|
|
Custom: true,
|
|
Fallback: true,
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Key: "section3setting1",
|
|
DisplayName: "thedisplayname",
|
|
Type: "custom",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.Title, func(t *testing.T) {
|
|
err := tc.manifest.IsValid()
|
|
if tc.ExpectError {
|
|
assert.Error(t, err)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsValidSettingsSchema(t *testing.T) {
|
|
testCases := []struct {
|
|
Title string
|
|
settingsSchema *PluginSettingsSchema
|
|
ExpectError bool
|
|
}{
|
|
{"Invalid Setting", &PluginSettingsSchema{Settings: []*PluginSetting{{Type: "invalid"}}}, true},
|
|
{"Happy case", &PluginSettingsSchema{Settings: []*PluginSetting{{Type: "text"}}}, false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.Title, func(t *testing.T) {
|
|
err := tc.settingsSchema.isValid()
|
|
if tc.ExpectError {
|
|
assert.Error(t, err)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPluginSettingsSectionIsValid(t *testing.T) {
|
|
for name, test := range map[string]struct {
|
|
Section PluginSettingsSection
|
|
ExpectedError string
|
|
}{
|
|
"missing key": {
|
|
Section: PluginSettingsSection{
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Type: "custom",
|
|
Placeholder: "some Text",
|
|
},
|
|
},
|
|
},
|
|
ExpectedError: "invalid empty Key",
|
|
},
|
|
"invalid setting": {
|
|
Section: PluginSettingsSection{
|
|
Key: "sectionKey",
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Type: "invalid",
|
|
},
|
|
},
|
|
},
|
|
ExpectedError: "invalid setting type: invalid",
|
|
},
|
|
"valid empty": {
|
|
Section: PluginSettingsSection{
|
|
Key: "sectionKey",
|
|
Settings: []*PluginSetting{},
|
|
},
|
|
},
|
|
"valid": {
|
|
Section: PluginSettingsSection{
|
|
Key: "sectionKey",
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Type: "custom",
|
|
Placeholder: "some Text",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
err := test.Section.IsValid()
|
|
if test.ExpectedError != "" {
|
|
assert.EqualError(t, err, test.ExpectedError)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSettingIsValid(t *testing.T) {
|
|
for name, test := range map[string]struct {
|
|
Setting PluginSetting
|
|
ExpectError bool
|
|
}{
|
|
"Invalid setting type": {
|
|
PluginSetting{Type: "invalid"},
|
|
true,
|
|
},
|
|
"RegenerateHelpText error": {
|
|
PluginSetting{Type: "text", RegenerateHelpText: "some text"},
|
|
true,
|
|
},
|
|
"Placeholder error": {
|
|
PluginSetting{Type: "bool", Placeholder: "some text"},
|
|
true,
|
|
},
|
|
"Nil Options": {
|
|
PluginSetting{Type: "bool"},
|
|
false,
|
|
},
|
|
"Options error": {
|
|
PluginSetting{Type: "generated", Options: []*PluginOption{}},
|
|
true,
|
|
},
|
|
"Options displayName error": {
|
|
PluginSetting{
|
|
Type: "radio",
|
|
Options: []*PluginOption{{
|
|
Value: "some value",
|
|
}},
|
|
},
|
|
true,
|
|
},
|
|
"Options value error": {
|
|
PluginSetting{
|
|
Type: "radio",
|
|
Options: []*PluginOption{{
|
|
DisplayName: "some name",
|
|
}},
|
|
},
|
|
true,
|
|
},
|
|
"Happy case": {
|
|
PluginSetting{
|
|
Type: "radio",
|
|
Options: []*PluginOption{{
|
|
DisplayName: "Name",
|
|
Value: "value",
|
|
}},
|
|
},
|
|
false,
|
|
},
|
|
"Valid number setting": {
|
|
PluginSetting{
|
|
Type: "number",
|
|
Default: 10,
|
|
},
|
|
false,
|
|
},
|
|
"Placeholder is disallowed for bool settings": {
|
|
PluginSetting{
|
|
Type: "bool",
|
|
Placeholder: "some Text",
|
|
},
|
|
true,
|
|
},
|
|
"Placeholder is allowed for text settings": {
|
|
PluginSetting{
|
|
Type: "text",
|
|
Placeholder: "some Text",
|
|
},
|
|
false,
|
|
},
|
|
"Placeholder is allowed for long text settings": {
|
|
PluginSetting{
|
|
Type: "longtext",
|
|
Placeholder: "some Text",
|
|
},
|
|
false,
|
|
},
|
|
"Placeholder is allowed for custom settings": {
|
|
PluginSetting{
|
|
Type: "custom",
|
|
Placeholder: "some Text",
|
|
},
|
|
false,
|
|
},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
err := test.Setting.isValid()
|
|
if test.ExpectError {
|
|
assert.Error(t, err)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConvertTypeToPluginSettingType(t *testing.T) {
|
|
testCases := []struct {
|
|
Title string
|
|
Type string
|
|
ExpectedSettingType PluginSettingType
|
|
ExpectError bool
|
|
}{
|
|
{"bool", "bool", Bool, false},
|
|
{"dropdown", "dropdown", Dropdown, false},
|
|
{"generated", "generated", Generated, false},
|
|
{"radio", "radio", Radio, false},
|
|
{"text", "text", Text, false},
|
|
{"longtext", "longtext", LongText, false},
|
|
{"username", "username", Username, false},
|
|
{"custom", "custom", Custom, false},
|
|
{"invalid", "invalid", Bool, true},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.Title, func(t *testing.T) {
|
|
settingType, err := convertTypeToPluginSettingType(tc.Type)
|
|
if !tc.ExpectError {
|
|
assert.Equal(t, settingType, tc.ExpectedSettingType)
|
|
} else {
|
|
assert.Error(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFindManifest(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
Filename string
|
|
Contents string
|
|
ExpectError bool
|
|
ExpectNotExist bool
|
|
}{
|
|
{"foo", "bar", true, true},
|
|
{"plugin.json", "bar", true, false},
|
|
{"plugin.json", `{"id": "foo"}`, false, false},
|
|
{"plugin.json", `{"id": "FOO"}`, false, false},
|
|
{"plugin.yaml", `id: foo`, false, false},
|
|
{"plugin.yaml", "bar", true, false},
|
|
{"plugin.yml", `id: foo`, false, false},
|
|
{"plugin.yml", `id: FOO`, false, false},
|
|
{"plugin.yml", "bar", true, false},
|
|
} {
|
|
dir, err := os.MkdirTemp("", "mm-plugin-test")
|
|
require.NoError(t, err)
|
|
defer os.RemoveAll(dir)
|
|
|
|
path := filepath.Join(dir, tc.Filename)
|
|
f, err := os.Create(path)
|
|
require.NoError(t, err)
|
|
_, err = f.WriteString(tc.Contents)
|
|
f.Close()
|
|
require.NoError(t, err)
|
|
|
|
m, mpath, err := FindManifest(dir)
|
|
assert.True(t, (err != nil) == tc.ExpectError, tc.Filename)
|
|
assert.True(t, (err != nil && os.IsNotExist(err)) == tc.ExpectNotExist, tc.Filename)
|
|
if !tc.ExpectNotExist {
|
|
assert.Equal(t, path, mpath, tc.Filename)
|
|
} else {
|
|
assert.Empty(t, mpath, tc.Filename)
|
|
}
|
|
if !tc.ExpectError {
|
|
require.NotNil(t, m, tc.Filename)
|
|
assert.NotEmpty(t, m.Id, tc.Filename)
|
|
assert.Equal(t, strings.ToLower(m.Id), m.Id)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestManifestUnmarshal(t *testing.T) {
|
|
expected := Manifest{
|
|
Id: "theid",
|
|
HomepageURL: "https://example.com",
|
|
SupportURL: "https://example.com/support",
|
|
IconPath: "assets/icon.svg",
|
|
MinServerVersion: "5.6.0",
|
|
Server: &ManifestServer{
|
|
Executable: "theexecutable",
|
|
Executables: map[string]string{
|
|
"linux-amd64": "theexecutable-linux-amd64",
|
|
"darwin-amd64": "theexecutable-darwin-amd64",
|
|
"windows-amd64": "theexecutable-windows-amd64",
|
|
"linux-arm64": "theexecutable-linux-arm64",
|
|
},
|
|
},
|
|
Webapp: &ManifestWebapp{
|
|
BundlePath: "thebundlepath",
|
|
},
|
|
SettingsSchema: &PluginSettingsSchema{
|
|
Header: "theheadertext",
|
|
Footer: "thefootertext",
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Key: "thesetting",
|
|
DisplayName: "thedisplayname",
|
|
Type: "dropdown",
|
|
HelpText: "thehelptext",
|
|
RegenerateHelpText: "theregeneratehelptext",
|
|
Placeholder: "theplaceholder",
|
|
Options: []*PluginOption{
|
|
{
|
|
DisplayName: "theoptiondisplayname",
|
|
Value: "thevalue",
|
|
},
|
|
},
|
|
Default: "thedefault",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
t.Run("yaml", func(t *testing.T) {
|
|
var yamlResult Manifest
|
|
require.NoError(t, yaml.Unmarshal([]byte(`
|
|
id: theid
|
|
homepage_url: https://example.com
|
|
support_url: https://example.com/support
|
|
icon_path: assets/icon.svg
|
|
min_server_version: 5.6.0
|
|
server:
|
|
executable: theexecutable
|
|
executables:
|
|
linux-amd64: theexecutable-linux-amd64
|
|
darwin-amd64: theexecutable-darwin-amd64
|
|
windows-amd64: theexecutable-windows-amd64
|
|
linux-arm64: theexecutable-linux-arm64
|
|
webapp:
|
|
bundle_path: thebundlepath
|
|
settings_schema:
|
|
header: theheadertext
|
|
footer: thefootertext
|
|
settings:
|
|
- key: thesetting
|
|
display_name: thedisplayname
|
|
type: dropdown
|
|
help_text: thehelptext
|
|
regenerate_help_text: theregeneratehelptext
|
|
placeholder: theplaceholder
|
|
options:
|
|
- display_name: theoptiondisplayname
|
|
value: thevalue
|
|
default: thedefault
|
|
`), &yamlResult))
|
|
assert.Equal(t, expected, yamlResult)
|
|
})
|
|
|
|
t.Run("json", func(t *testing.T) {
|
|
var jsonResult Manifest
|
|
require.NoError(t, json.Unmarshal([]byte(`{
|
|
"id": "theid",
|
|
"homepage_url": "https://example.com",
|
|
"support_url": "https://example.com/support",
|
|
"icon_path": "assets/icon.svg",
|
|
"min_server_version": "5.6.0",
|
|
"server": {
|
|
"executable": "theexecutable",
|
|
"executables": {
|
|
"linux-amd64": "theexecutable-linux-amd64",
|
|
"darwin-amd64": "theexecutable-darwin-amd64",
|
|
"windows-amd64": "theexecutable-windows-amd64",
|
|
"linux-arm64": "theexecutable-linux-arm64"
|
|
}
|
|
},
|
|
"webapp": {
|
|
"bundle_path": "thebundlepath"
|
|
},
|
|
"settings_schema": {
|
|
"header": "theheadertext",
|
|
"footer": "thefootertext",
|
|
"settings": [
|
|
{
|
|
"key": "thesetting",
|
|
"display_name": "thedisplayname",
|
|
"type": "dropdown",
|
|
"help_text": "thehelptext",
|
|
"regenerate_help_text": "theregeneratehelptext",
|
|
"placeholder": "theplaceholder",
|
|
"options": [
|
|
{
|
|
"display_name": "theoptiondisplayname",
|
|
"value": "thevalue"
|
|
}
|
|
],
|
|
"default": "thedefault"
|
|
}
|
|
]
|
|
}
|
|
}`), &jsonResult))
|
|
assert.Equal(t, expected, jsonResult)
|
|
})
|
|
}
|
|
|
|
func TestFindManifest_FileErrors(t *testing.T) {
|
|
for _, tc := range []string{"plugin.yaml", "plugin.json"} {
|
|
dir, err := os.MkdirTemp("", "mm-plugin-test")
|
|
require.NoError(t, err)
|
|
defer os.RemoveAll(dir)
|
|
|
|
path := filepath.Join(dir, tc)
|
|
require.NoError(t, os.Mkdir(path, 0700))
|
|
|
|
m, mpath, err := FindManifest(dir)
|
|
assert.Nil(t, m)
|
|
assert.Equal(t, path, mpath)
|
|
assert.Error(t, err, tc)
|
|
assert.False(t, os.IsNotExist(err), tc)
|
|
}
|
|
}
|
|
|
|
func TestFindManifest_FolderPermission(t *testing.T) {
|
|
if os.Geteuid() == 0 {
|
|
t.Skip("skipping test while running as root: can't effectively remove permissions")
|
|
}
|
|
|
|
for _, tc := range []string{"plugin.yaml", "plugin.json"} {
|
|
dir, err := os.MkdirTemp("", "mm-plugin-test")
|
|
require.NoError(t, err)
|
|
defer os.RemoveAll(dir)
|
|
|
|
path := filepath.Join(dir, tc)
|
|
require.NoError(t, os.Mkdir(path, 0700))
|
|
|
|
// User does not have permission in the plugin folder
|
|
err = os.Chmod(dir, 0066)
|
|
require.NoError(t, err)
|
|
|
|
m, mpath, err := FindManifest(dir)
|
|
assert.Nil(t, m)
|
|
assert.Equal(t, "", mpath)
|
|
assert.Error(t, err, tc)
|
|
assert.False(t, os.IsNotExist(err), tc)
|
|
}
|
|
}
|
|
|
|
func TestManifestHasClient(t *testing.T) {
|
|
manifest := &Manifest{
|
|
Id: "theid",
|
|
Server: &ManifestServer{
|
|
Executable: "theexecutable",
|
|
},
|
|
Webapp: &ManifestWebapp{
|
|
BundlePath: "thebundlepath",
|
|
},
|
|
}
|
|
|
|
assert.True(t, manifest.HasClient())
|
|
|
|
manifest.Webapp = nil
|
|
assert.False(t, manifest.HasClient())
|
|
}
|
|
|
|
func TestManifestClientManifest(t *testing.T) {
|
|
manifest := &Manifest{
|
|
Id: "theid",
|
|
Name: "thename",
|
|
Description: "thedescription",
|
|
Version: "0.0.1",
|
|
MinServerVersion: "5.6.0",
|
|
Server: &ManifestServer{
|
|
Executable: "theexecutable",
|
|
},
|
|
Webapp: &ManifestWebapp{
|
|
BundlePath: "thebundlepath",
|
|
BundleHash: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
|
|
},
|
|
SettingsSchema: &PluginSettingsSchema{
|
|
Header: "theheadertext",
|
|
Footer: "thefootertext",
|
|
Settings: []*PluginSetting{
|
|
{
|
|
Key: "thesetting",
|
|
DisplayName: "thedisplayname",
|
|
Type: "dropdown",
|
|
HelpText: "thehelptext",
|
|
RegenerateHelpText: "theregeneratehelptext",
|
|
Placeholder: "theplaceholder",
|
|
Options: []*PluginOption{
|
|
{
|
|
DisplayName: "theoptiondisplayname",
|
|
Value: "thevalue",
|
|
},
|
|
},
|
|
Default: "thedefault",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
sanitized := manifest.ClientManifest()
|
|
|
|
assert.Equal(t, manifest.Id, sanitized.Id)
|
|
assert.Equal(t, manifest.Version, sanitized.Version)
|
|
assert.Equal(t, manifest.MinServerVersion, sanitized.MinServerVersion)
|
|
assert.Equal(t, "/static/theid/theid_000102030405060708090a0b0c0d0e0f_bundle.js", sanitized.Webapp.BundlePath)
|
|
assert.Equal(t, manifest.Webapp.BundleHash, sanitized.Webapp.BundleHash)
|
|
assert.Equal(t, manifest.SettingsSchema, sanitized.SettingsSchema)
|
|
assert.Empty(t, sanitized.Name)
|
|
assert.Empty(t, sanitized.Description)
|
|
assert.Empty(t, sanitized.Server)
|
|
|
|
assert.NotEmpty(t, manifest.Id)
|
|
assert.NotEmpty(t, manifest.Version)
|
|
assert.NotEmpty(t, manifest.MinServerVersion)
|
|
assert.NotEmpty(t, manifest.Webapp)
|
|
assert.NotEmpty(t, manifest.Name)
|
|
assert.NotEmpty(t, manifest.Description)
|
|
assert.NotEmpty(t, manifest.Server)
|
|
assert.NotEmpty(t, manifest.SettingsSchema)
|
|
}
|
|
|
|
func TestManifestGetExecutableForRuntime(t *testing.T) {
|
|
testCases := []struct {
|
|
Description string
|
|
Manifest *Manifest
|
|
GoOs string
|
|
GoArch string
|
|
ExpectedExecutable string
|
|
}{
|
|
{
|
|
"no server",
|
|
&Manifest{},
|
|
"linux",
|
|
"amd64",
|
|
"",
|
|
},
|
|
{
|
|
"no executable",
|
|
&Manifest{
|
|
Server: &ManifestServer{},
|
|
},
|
|
"linux",
|
|
"amd64",
|
|
"",
|
|
},
|
|
{
|
|
"single executable",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executable: "path/to/executable",
|
|
},
|
|
},
|
|
"linux",
|
|
"amd64",
|
|
"path/to/executable",
|
|
},
|
|
{
|
|
"single executable, different runtime",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executable: "path/to/executable",
|
|
},
|
|
},
|
|
"darwin",
|
|
"amd64",
|
|
"path/to/executable",
|
|
},
|
|
{
|
|
"multiple executables, no match",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executables: map[string]string{
|
|
"linux-amd64": "linux-amd64/path/to/executable",
|
|
"darwin-amd64": "darwin-amd64/path/to/executable",
|
|
"windows-amd64": "windows-amd64/path/to/executable",
|
|
"linux-arm64": "linux-arm64/path/to/executable",
|
|
},
|
|
},
|
|
},
|
|
"other",
|
|
"amd64",
|
|
"",
|
|
},
|
|
{
|
|
"multiple executables, linux-amd64 match",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executables: map[string]string{
|
|
"linux-amd64": "linux-amd64/path/to/executable",
|
|
"darwin-amd64": "darwin-amd64/path/to/executable",
|
|
"windows-amd64": "windows-amd64/path/to/executable",
|
|
"linux-arm64": "linux-arm64/path/to/executable",
|
|
},
|
|
},
|
|
},
|
|
"linux",
|
|
"amd64",
|
|
"linux-amd64/path/to/executable",
|
|
},
|
|
{
|
|
"multiple executables, linux-amd64 match, single executable ignored",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executables: map[string]string{
|
|
"linux-amd64": "linux-amd64/path/to/executable",
|
|
"darwin-amd64": "darwin-amd64/path/to/executable",
|
|
"windows-amd64": "windows-amd64/path/to/executable",
|
|
"linux-arm64": "linux-arm64/path/to/executable",
|
|
},
|
|
Executable: "path/to/executable",
|
|
},
|
|
},
|
|
"linux",
|
|
"amd64",
|
|
"linux-amd64/path/to/executable",
|
|
},
|
|
{
|
|
"multiple executables, darwin-amd64 match",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executables: map[string]string{
|
|
"linux-amd64": "linux-amd64/path/to/executable",
|
|
"darwin-amd64": "darwin-amd64/path/to/executable",
|
|
"windows-amd64": "windows-amd64/path/to/executable",
|
|
"linux-arm64": "linux-arm64/path/to/executable",
|
|
},
|
|
},
|
|
},
|
|
"darwin",
|
|
"amd64",
|
|
"darwin-amd64/path/to/executable",
|
|
},
|
|
{
|
|
"multiple executables, windows-amd64 match",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executables: map[string]string{
|
|
"linux-amd64": "linux-amd64/path/to/executable",
|
|
"darwin-amd64": "darwin-amd64/path/to/executable",
|
|
"windows-amd64": "windows-amd64/path/to/executable",
|
|
"linux-arm64": "linux-arm64/path/to/executable",
|
|
},
|
|
},
|
|
},
|
|
"windows",
|
|
"amd64",
|
|
"windows-amd64/path/to/executable",
|
|
},
|
|
{
|
|
"multiple executables, no match, single executable fallback",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executables: map[string]string{
|
|
"linux-amd64": "linux-amd64/path/to/executable",
|
|
"darwin-amd64": "darwin-amd64/path/to/executable",
|
|
"windows-amd64": "windows-amd64/path/to/executable",
|
|
"linux-arm64": "linux-arm64/path/to/executable",
|
|
},
|
|
Executable: "path/to/executable",
|
|
},
|
|
},
|
|
"other",
|
|
"amd64",
|
|
"path/to/executable",
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.Description, func(t *testing.T) {
|
|
assert.Equal(
|
|
t,
|
|
testCase.ExpectedExecutable,
|
|
testCase.Manifest.GetExecutableForRuntime(testCase.GoOs, testCase.GoArch),
|
|
)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManifestHasServer(t *testing.T) {
|
|
testCases := []struct {
|
|
Description string
|
|
Manifest *Manifest
|
|
Expected bool
|
|
}{
|
|
{
|
|
"no server",
|
|
&Manifest{},
|
|
false,
|
|
},
|
|
{
|
|
"no executable, but server still considered present",
|
|
&Manifest{
|
|
Server: &ManifestServer{},
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"single executable",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executable: "path/to/executable",
|
|
},
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"multiple executables",
|
|
&Manifest{
|
|
Server: &ManifestServer{
|
|
Executables: map[string]string{
|
|
"linux-amd64": "linux-amd64/path/to/executable",
|
|
"darwin-amd64": "darwin-amd64/path/to/executable",
|
|
"windows-amd64": "windows-amd64/path/to/executable",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.Description, func(t *testing.T) {
|
|
assert.Equal(t, testCase.Expected, testCase.Manifest.HasServer())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManifestHasWebapp(t *testing.T) {
|
|
testCases := []struct {
|
|
Description string
|
|
Manifest *Manifest
|
|
Expected bool
|
|
}{
|
|
{
|
|
"no webapp",
|
|
&Manifest{},
|
|
false,
|
|
},
|
|
{
|
|
"no bundle path, but webapp still considered present",
|
|
&Manifest{
|
|
Webapp: &ManifestWebapp{},
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"bundle path defined",
|
|
&Manifest{
|
|
Webapp: &ManifestWebapp{
|
|
BundlePath: "path/to/bundle",
|
|
},
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.Description, func(t *testing.T) {
|
|
assert.Equal(t, testCase.Expected, testCase.Manifest.HasWebapp())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManifestMeetMinServerVersion(t *testing.T) {
|
|
for name, test := range map[string]struct {
|
|
MinServerVersion string
|
|
ServerVersion string
|
|
ShouldError bool
|
|
ShouldFulfill bool
|
|
}{
|
|
"generously fulfilled": {
|
|
MinServerVersion: "5.5.0",
|
|
ServerVersion: "5.6.0",
|
|
ShouldError: false,
|
|
ShouldFulfill: true,
|
|
},
|
|
"exactly fulfilled": {
|
|
MinServerVersion: "5.6.0",
|
|
ServerVersion: "5.6.0",
|
|
ShouldError: false,
|
|
ShouldFulfill: true,
|
|
},
|
|
"not fulfilled": {
|
|
MinServerVersion: "5.6.0",
|
|
ServerVersion: "5.5.0",
|
|
ShouldError: false,
|
|
ShouldFulfill: false,
|
|
},
|
|
"fail to parse MinServerVersion": {
|
|
MinServerVersion: "abc",
|
|
ServerVersion: "5.5.0",
|
|
ShouldError: true,
|
|
},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
manifest := Manifest{
|
|
MinServerVersion: test.MinServerVersion,
|
|
}
|
|
fulfilled, err := manifest.MeetMinServerVersion(test.ServerVersion)
|
|
|
|
if test.ShouldError {
|
|
assert.NotNil(err)
|
|
assert.False(fulfilled)
|
|
return
|
|
}
|
|
assert.Nil(err)
|
|
assert.Equal(test.ShouldFulfill, fulfilled)
|
|
})
|
|
}
|
|
}
|