413 lines
11 KiB
Go
413 lines
11 KiB
Go
package config
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/pelletier/go-toml/v2"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/urfave/cli/v2"
|
|
|
|
cmd "pages-server/cli"
|
|
)
|
|
|
|
func runApp(t *testing.T, fn func(*cli.Context) error, args []string) {
|
|
app := cmd.CreatePagesApp()
|
|
app.Action = fn
|
|
|
|
appCtx, appCancel := context.WithCancel(context.Background())
|
|
defer appCancel()
|
|
|
|
// os.Args always contains the binary name
|
|
args = append([]string{"testing"}, args...)
|
|
|
|
err := app.RunContext(appCtx, args)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
// fixArrayFromCtx fixes the number of "changed" strings in a string slice according to the number of values in the context.
|
|
// This is a workaround because the cli library has a bug where the number of values in the context gets bigger the more tests are run.
|
|
func fixArrayFromCtx(ctx *cli.Context, key string, expected []string) []string {
|
|
if ctx.IsSet(key) {
|
|
ctxSlice := ctx.StringSlice(key)
|
|
|
|
if len(ctxSlice) > 1 {
|
|
for i := 1; i < len(ctxSlice); i++ {
|
|
expected = append([]string{"changed"}, expected...)
|
|
}
|
|
}
|
|
}
|
|
|
|
return expected
|
|
}
|
|
|
|
func readTestConfig() (*Config, error) {
|
|
content, err := os.ReadFile("assets/test_config.toml")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
expectedConfig := NewDefaultConfig()
|
|
err = toml.Unmarshal(content, &expectedConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &expectedConfig, nil
|
|
}
|
|
|
|
func TestReadConfigShouldReturnEmptyConfigWhenConfigArgEmpty(t *testing.T) {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg, err := ReadConfig(ctx)
|
|
expected := NewDefaultConfig()
|
|
assert.Equal(t, &expected, cfg)
|
|
|
|
return err
|
|
},
|
|
[]string{},
|
|
)
|
|
}
|
|
|
|
func TestReadConfigShouldReturnConfigFromFileWhenConfigArgPresent(t *testing.T) {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg, err := ReadConfig(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
expectedConfig, err := readTestConfig()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
[]string{"--config-file", "assets/test_config.toml"},
|
|
)
|
|
}
|
|
|
|
func TestValuesReadFromConfigFileShouldBeOverwrittenByArgs(t *testing.T) {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg, err := ReadConfig(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
MergeConfig(ctx, cfg)
|
|
|
|
expectedConfig, err := readTestConfig()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
expectedConfig.LogLevel = "debug"
|
|
expectedConfig.Forge.Root = "not-codeberg.org"
|
|
expectedConfig.Server.Host = "172.17.0.2"
|
|
expectedConfig.Server.BlacklistedPaths = append(expectedConfig.Server.BlacklistedPaths, ALWAYS_BLACKLISTED_PATHS...)
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
[]string{
|
|
"--config-file", "assets/test_config.toml",
|
|
"--log-level", "debug",
|
|
"--forge-root", "not-codeberg.org",
|
|
"--host", "172.17.0.2",
|
|
},
|
|
)
|
|
}
|
|
|
|
func TestMergeConfigShouldReplaceAllExistingValuesGivenAllArgsExist(t *testing.T) {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg := &Config{
|
|
LogLevel: "original",
|
|
Server: ServerConfig{
|
|
Host: "original",
|
|
Port: 8080,
|
|
|
|
MainDomain: "original",
|
|
RawDomain: "original",
|
|
PagesBranches: []string{"original"},
|
|
AllowedCorsDomains: []string{"original"},
|
|
BlacklistedPaths: []string{"original"},
|
|
},
|
|
Forge: ForgeConfig{
|
|
Root: "original",
|
|
Token: "original",
|
|
LFSEnabled: false,
|
|
FollowSymlinks: false,
|
|
DefaultMimeType: "original",
|
|
ForbiddenMimeTypes: []string{"original"},
|
|
},
|
|
}
|
|
|
|
MergeConfig(ctx, cfg)
|
|
|
|
expectedConfig := &Config{
|
|
LogLevel: "changed",
|
|
Server: ServerConfig{
|
|
Host: "changed",
|
|
Port: 8443,
|
|
MainDomain: "changed",
|
|
RawDomain: "changed",
|
|
PagesBranches: []string{"changed"},
|
|
AllowedCorsDomains: []string{"changed"},
|
|
BlacklistedPaths: append([]string{"changed"}, ALWAYS_BLACKLISTED_PATHS...),
|
|
},
|
|
Forge: ForgeConfig{
|
|
Root: "changed",
|
|
Token: "changed",
|
|
LFSEnabled: true,
|
|
FollowSymlinks: true,
|
|
DefaultMimeType: "changed",
|
|
ForbiddenMimeTypes: []string{"changed"},
|
|
},
|
|
}
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
[]string{
|
|
"--log-level", "changed",
|
|
// Server
|
|
"--pages-domain", "changed",
|
|
"--raw-domain", "changed",
|
|
"--allowed-cors-domains", "changed",
|
|
"--blacklisted-paths", "changed",
|
|
"--pages-branch", "changed",
|
|
"--host", "changed",
|
|
"--port", "8443",
|
|
// Forge
|
|
"--forge-root", "changed",
|
|
"--forge-api-token", "changed",
|
|
"--enable-lfs-support",
|
|
"--enable-symlink-support",
|
|
"--default-mime-type", "changed",
|
|
"--forbidden-mime-types", "changed",
|
|
// Database
|
|
"--db-type", "changed",
|
|
"--db-conn", "changed",
|
|
// ACME
|
|
"--acme-email", "changed",
|
|
"--acme-api-endpoint", "changed",
|
|
"--acme-accept-terms",
|
|
"--acme-use-rate-limits",
|
|
"--acme-eab-hmac", "changed",
|
|
"--acme-eab-kid", "changed",
|
|
"--dns-provider", "changed",
|
|
"--no-dns-01",
|
|
"--acme-account-config", "changed",
|
|
},
|
|
)
|
|
}
|
|
|
|
func TestMergeServerConfigShouldReplaceAllExistingValuesGivenAllArgsExist(t *testing.T) {
|
|
for range []uint8{0, 1} {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg := &ServerConfig{
|
|
Host: "original",
|
|
Port: 8080,
|
|
MainDomain: "original",
|
|
RawDomain: "original",
|
|
AllowedCorsDomains: []string{"original"},
|
|
BlacklistedPaths: []string{"original"},
|
|
}
|
|
|
|
mergeServerConfig(ctx, cfg)
|
|
|
|
expectedConfig := &ServerConfig{
|
|
Host: "changed",
|
|
Port: 8080,
|
|
MainDomain: "changed",
|
|
RawDomain: "changed",
|
|
AllowedCorsDomains: fixArrayFromCtx(ctx, "allowed-cors-domains", []string{"changed"}),
|
|
BlacklistedPaths: fixArrayFromCtx(ctx, "blacklisted-paths", append([]string{"changed"}, ALWAYS_BLACKLISTED_PATHS...)),
|
|
}
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
[]string{
|
|
"--pages-domain", "changed",
|
|
"--raw-domain", "changed",
|
|
"--allowed-cors-domains", "changed",
|
|
"--blacklisted-paths", "changed",
|
|
"--host", "changed",
|
|
"--port", "8443",
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestMergeServerConfigShouldReplaceOnlyOneValueExistingValueGivenOnlyOneArgExists(t *testing.T) {
|
|
type testValuePair struct {
|
|
args []string
|
|
callback func(*ServerConfig)
|
|
}
|
|
testValuePairs := []testValuePair{
|
|
{args: []string{"--host", "changed"}, callback: func(sc *ServerConfig) { sc.Host = "changed" }},
|
|
{args: []string{"--port", "8080"}, callback: func(sc *ServerConfig) { sc.Port = 8080 }},
|
|
{args: []string{"--pages-domain", "changed"}, callback: func(sc *ServerConfig) { sc.MainDomain = "changed" }},
|
|
{args: []string{"--raw-domain", "changed"}, callback: func(sc *ServerConfig) { sc.RawDomain = "changed" }},
|
|
{args: []string{"--pages-branch", "changed"}, callback: func(sc *ServerConfig) { sc.PagesBranches = []string{"changed"} }},
|
|
{args: []string{"--allowed-cors-domains", "changed"}, callback: func(sc *ServerConfig) { sc.AllowedCorsDomains = []string{"changed"} }},
|
|
{args: []string{"--blacklisted-paths", "changed"}, callback: func(sc *ServerConfig) { sc.BlacklistedPaths = []string{"changed"} }},
|
|
}
|
|
|
|
for _, pair := range testValuePairs {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg := ServerConfig{
|
|
Host: "original",
|
|
Port: 8080,
|
|
MainDomain: "original",
|
|
RawDomain: "original",
|
|
PagesBranches: []string{"original"},
|
|
AllowedCorsDomains: []string{"original"},
|
|
BlacklistedPaths: []string{"original"},
|
|
}
|
|
|
|
expectedConfig := cfg
|
|
pair.callback(&expectedConfig)
|
|
expectedConfig.BlacklistedPaths = append(expectedConfig.BlacklistedPaths, ALWAYS_BLACKLISTED_PATHS...)
|
|
|
|
expectedConfig.PagesBranches = fixArrayFromCtx(ctx, "pages-branch", expectedConfig.PagesBranches)
|
|
expectedConfig.AllowedCorsDomains = fixArrayFromCtx(ctx, "allowed-cors-domains", expectedConfig.AllowedCorsDomains)
|
|
expectedConfig.BlacklistedPaths = fixArrayFromCtx(ctx, "blacklisted-paths", expectedConfig.BlacklistedPaths)
|
|
|
|
mergeServerConfig(ctx, &cfg)
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
pair.args,
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestMergeForgeConfigShouldReplaceAllExistingValuesGivenAllArgsExist(t *testing.T) {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg := &ForgeConfig{
|
|
Root: "original",
|
|
Token: "original",
|
|
LFSEnabled: false,
|
|
FollowSymlinks: false,
|
|
DefaultMimeType: "original",
|
|
ForbiddenMimeTypes: []string{"original"},
|
|
}
|
|
|
|
mergeForgeConfig(ctx, cfg)
|
|
|
|
expectedConfig := &ForgeConfig{
|
|
Root: "changed",
|
|
Token: "changed",
|
|
LFSEnabled: true,
|
|
FollowSymlinks: true,
|
|
DefaultMimeType: "changed",
|
|
ForbiddenMimeTypes: fixArrayFromCtx(ctx, "forbidden-mime-types", []string{"changed"}),
|
|
}
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
[]string{
|
|
"--forge-root", "changed",
|
|
"--forge-api-token", "changed",
|
|
"--enable-lfs-support",
|
|
"--enable-symlink-support",
|
|
"--default-mime-type", "changed",
|
|
"--forbidden-mime-types", "changed",
|
|
},
|
|
)
|
|
}
|
|
|
|
func TestMergeForgeConfigShouldReplaceOnlyOneValueExistingValueGivenOnlyOneArgExists(t *testing.T) {
|
|
type testValuePair struct {
|
|
args []string
|
|
callback func(*ForgeConfig)
|
|
}
|
|
testValuePairs := []testValuePair{
|
|
{args: []string{"--forge-root", "changed"}, callback: func(gc *ForgeConfig) { gc.Root = "changed" }},
|
|
{args: []string{"--forge-api-token", "changed"}, callback: func(gc *ForgeConfig) { gc.Token = "changed" }},
|
|
{args: []string{"--enable-lfs-support"}, callback: func(gc *ForgeConfig) { gc.LFSEnabled = true }},
|
|
{args: []string{"--enable-symlink-support"}, callback: func(gc *ForgeConfig) { gc.FollowSymlinks = true }},
|
|
{args: []string{"--default-mime-type", "changed"}, callback: func(gc *ForgeConfig) { gc.DefaultMimeType = "changed" }},
|
|
{args: []string{"--forbidden-mime-types", "changed"}, callback: func(gc *ForgeConfig) { gc.ForbiddenMimeTypes = []string{"changed"} }},
|
|
}
|
|
|
|
for _, pair := range testValuePairs {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg := ForgeConfig{
|
|
Root: "original",
|
|
Token: "original",
|
|
LFSEnabled: false,
|
|
FollowSymlinks: false,
|
|
DefaultMimeType: "original",
|
|
ForbiddenMimeTypes: []string{"original"},
|
|
}
|
|
|
|
expectedConfig := cfg
|
|
pair.callback(&expectedConfig)
|
|
|
|
mergeForgeConfig(ctx, &cfg)
|
|
|
|
expectedConfig.ForbiddenMimeTypes = fixArrayFromCtx(ctx, "forbidden-mime-types", expectedConfig.ForbiddenMimeTypes)
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
pair.args,
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestMergeForgeConfigShouldReplaceValuesGivenGiteaOptionsExist(t *testing.T) {
|
|
runApp(
|
|
t,
|
|
func(ctx *cli.Context) error {
|
|
cfg := &ForgeConfig{
|
|
Root: "original",
|
|
Token: "original",
|
|
}
|
|
|
|
mergeForgeConfig(ctx, cfg)
|
|
|
|
expectedConfig := &ForgeConfig{
|
|
Root: "changed",
|
|
Token: "changed",
|
|
}
|
|
|
|
assert.Equal(t, expectedConfig, cfg)
|
|
|
|
return nil
|
|
},
|
|
[]string{
|
|
"--gitea-root", "changed",
|
|
"--gitea-api-token", "changed",
|
|
},
|
|
)
|
|
}
|