modules/setting/config_example_test.go - master - uzer_007/Rixea

modules/setting/config_example_test.go
689 строк22 KB
uzer_007
feat: первая версия Rixea
02 авг 2026, 22:16
02 авг 2026, 22:16d4f7504
// Copyright 2026 Uzer_007. All rights reserved.
// SPDX-License-Identifier: MIT

package setting

import (
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestAppExampleConfigUsesSafeRixeaSettings(t *testing.T) {
	path := filepath.Join("..", "..", "custom", "conf", "app.example.ini")
	source, err := os.ReadFile(path)
	require.NoError(t, err)

	cfg, err := NewConfigProviderFromData(string(source))
	require.NoError(t, err)

	assert.Equal(t, "Rixea", cfg.Section("").Key("APP_NAME").String())
	assert.Equal(t, "reindexer", cfg.Section("database").Key("DB_TYPE").String())
	assert.Equal(t, "file", cfg.Section("session").Key("PROVIDER").String())
	assert.Equal(t, "true", cfg.Section("security").Key("DISABLE_QUERY_AUTH_TOKEN").String())
	assert.Equal(t, "true", cfg.Section("security").Key("ONLY_ALLOW_PUSH_IF_RIXEA_ENVIRONMENT_SET").String())
	assert.Empty(t, cfg.Section("security").Key("SECRET_KEY").String())
	assert.Empty(t, cfg.Section("security").Key("INTERNAL_TOKEN").String())
	assert.Equal(t, "console", cfg.Section("log").Key("MODE").String())
	assert.Equal(t, "ru-RU,en-US", cfg.Section("i18n").Key("LANGS").String())
	assert.Equal(t, "16", cfg.Section("actions").Key("MAX_CONCURRENT_TASK_PICKS").String())
	assert.Equal(t, "false", cfg.Section("indexer").Key("REPO_INDEXER_ENABLED").String())
	assert.Equal(t, "true", cfg.Section("indexer").Key("REPO_INDEXER_EXCLUDE_VENDORED").String())
	assert.Equal(t, "image", cfg.Section("service").Key("CAPTCHA_TYPE").String())
	assert.Equal(t, "false", cfg.Section("service").Key("ENABLE_CAPTCHA").String())
	assert.Empty(t, cfg.Section("service").Key("RECAPTCHA_SECRET").String())
	assert.Empty(t, cfg.Section("service").Key("HCAPTCHA_SECRET").String())
	assert.Empty(t, cfg.Section("service").Key("MCAPTCHA_SECRET").String())
	assert.Empty(t, cfg.Section("service").Key("CF_TURNSTILE_SECRET").String())

	upperSource := strings.ToUpper(string(source))
	assert.NotContains(t, upperSource, "COOKIE_USERNAME")
	assert.NotContains(t, upperSource, "DISABLE_GRAVATAR")
	assert.NotContains(t, upperSource, "ENABLE_FEDERATED_AVATAR")
	assert.NotContains(t, upperSource, "SEND_BUFFER_LEN")
	assert.NotContains(t, upperSource, "ONLY_ALLOW_PUSH_IF_GITEA_ENVIRONMENT_SET")
	assert.NotContains(t, upperSource, "ISSUE_INDEXER_TYPE")
	assert.NotContains(t, upperSource, "REPO_INDEXER_TYPE")
	assert.NotContains(t, upperSource, "TYPE_BLEVE_MAX_FUZZINESS")
	assert.NotContains(t, upperSource, "ENABLE_SUCCESS_NOTICE")
	assert.NotContains(t, upperSource, "NO_SUCCESS_NOTICE")
}

func TestAppExampleConfigDocumentsServiceSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"SERVICE.ACTIVE_CODE_LIVE_MINUTES",
		"SERVICE.ALLOW_ONLY_EXTERNAL_REGISTRATION",
		"SERVICE.ALLOW_ONLY_INTERNAL_REGISTRATION",
		"SERVICE.CAPTCHA_TYPE",
		"SERVICE.CF_TURNSTILE_SECRET",
		"SERVICE.CF_TURNSTILE_SITEKEY",
		"SERVICE.ENABLE_REVERSE_PROXY_EMAIL",
		"SERVICE.ENABLE_REVERSE_PROXY_FULL_NAME",
		"SERVICE.ENABLE_USER_HEATMAP",
		"SERVICE.HCAPTCHA_SECRET",
		"SERVICE.HCAPTCHA_SITEKEY",
		"SERVICE.MCAPTCHA_SECRET",
		"SERVICE.MCAPTCHA_SITEKEY",
		"SERVICE.MCAPTCHA_URL",
		"SERVICE.RECAPTCHA_SECRET",
		"SERVICE.RECAPTCHA_SITEKEY",
		"SERVICE.RECAPTCHA_URL",
		"SERVICE.REQUIRE_EXTERNAL_REGISTRATION_CAPTCHA",
		"SERVICE.REQUIRE_EXTERNAL_REGISTRATION_PASSWORD",
		"SERVICE.RESET_PASSWD_CODE_LIVE_MINUTES",
		"SERVICE.USER_DELETE_WITH_COMMENTS_MAX_TIME",
		"SERVICE.USER_LOCATION_MAP_URL",
		"SERVICE.EXPLORE.DISABLE_CODE_PAGE",
		"SERVICE.EXPLORE.DISABLE_ORGANIZATIONS_PAGE",
		"SERVICE.EXPLORE.DISABLE_USERS_PAGE",
		"SERVICE.EXPLORE.REQUIRE_SIGNIN_VIEW",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsRepositorySurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"REPOSITORY.ACCESS_CONTROL_ALLOW_ORIGIN",
		"REPOSITORY.ALLOW_DELETION_OF_UNADOPTED_REPOSITORIES",
		"REPOSITORY.ALLOW_FORK_WITHOUT_MAXIMUM_LIMIT",
		"REPOSITORY.ANSI_CHARSET",
		"REPOSITORY.DEFAULT_FORK_REPO_UNITS",
		"REPOSITORY.DEFAULT_MIRROR_REPO_UNITS",
		"REPOSITORY.DEFAULT_PUSH_CREATE_PRIVATE",
		"REPOSITORY.DEFAULT_REPO_UNITS",
		"REPOSITORY.DEFAULT_TEMPLATE_REPO_UNITS",
		"REPOSITORY.DETECTED_CHARSETS_ORDER",
		"REPOSITORY.DISABLED_REPO_UNITS",
		"REPOSITORY.EDITOR.LINE_WRAP_EXTENSIONS",
		"REPOSITORY.GO_GET_CLONE_URL_PROTOCOL",
		"REPOSITORY.ISSUE.LOCK_REASONS",
		"REPOSITORY.ISSUE.MAX_PINNED",
		"REPOSITORY.MAX_CREATION_LIMIT",
		"REPOSITORY.PREFERRED_LICENSES",
		"REPOSITORY.PREFIX_ARCHIVE_FILES",
		"REPOSITORY.PULL-REQUEST.ADD_CO_COMMITTER_TRAILERS",
		"REPOSITORY.PULL-REQUEST.CLOSE_KEYWORDS",
		"REPOSITORY.PULL-REQUEST.DEFAULT_DELETE_BRANCH_AFTER_MERGE",
		"REPOSITORY.PULL-REQUEST.DEFAULT_MERGE_MESSAGE_ALL_AUTHORS",
		"REPOSITORY.PULL-REQUEST.DEFAULT_MERGE_MESSAGE_COMMITS_LIMIT",
		"REPOSITORY.PULL-REQUEST.DEFAULT_MERGE_MESSAGE_MAX_APPROVERS",
		"REPOSITORY.PULL-REQUEST.DEFAULT_MERGE_MESSAGE_OFFICIAL_APPROVERS_ONLY",
		"REPOSITORY.PULL-REQUEST.DEFAULT_MERGE_MESSAGE_SIZE",
		"REPOSITORY.PULL-REQUEST.DEFAULT_MERGE_STYLE",
		"REPOSITORY.PULL-REQUEST.DEFAULT_TITLE_SOURCE",
		"REPOSITORY.PULL-REQUEST.DELAY_CHECK_FOR_INACTIVE_DAYS",
		"REPOSITORY.PULL-REQUEST.POPULATE_SQUASH_COMMENT_WITH_COMMIT_MESSAGES",
		"REPOSITORY.PULL-REQUEST.REOPEN_KEYWORDS",
		"REPOSITORY.PULL-REQUEST.RETARGET_CHILDREN_ON_MERGE",
		"REPOSITORY.PULL-REQUEST.WORK_IN_PROGRESS_PREFIXES",
		"REPOSITORY.RELEASE.ALLOWED_TYPES",
		"REPOSITORY.RELEASE.DEFAULT_PAGING_NUM",
		"REPOSITORY.RELEASE.FILE_MAX_SIZE",
		"REPOSITORY.RELEASE.MAX_FILES",
		"REPOSITORY.SCRIPT_TYPE",
		"REPOSITORY.SIGNING.CRUD_ACTIONS",
		"REPOSITORY.SIGNING.DEFAULT_TRUST_MODEL",
		"REPOSITORY.SIGNING.INITIAL_COMMIT",
		"REPOSITORY.SIGNING.MERGES",
		"REPOSITORY.SIGNING.SIGNING_EMAIL",
		"REPOSITORY.SIGNING.SIGNING_FORMAT",
		"REPOSITORY.SIGNING.SIGNING_KEY",
		"REPOSITORY.SIGNING.SIGNING_NAME",
		"REPOSITORY.SIGNING.TRUSTED_SSH_KEYS",
		"REPOSITORY.SIGNING.WIKI",
		"REPOSITORY.UPLOAD.ALLOWED_TYPES",
		"REPOSITORY.UPLOAD.ENABLED",
		"REPOSITORY.UPLOAD.FILE_MAX_SIZE",
		"REPOSITORY.UPLOAD.MAX_FILES",
		"REPOSITORY.USE_COMPAT_SSH_URI",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsCronSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)
	tasks := map[string][]string{
		"ARCHIVE_CLEANUP":                     {"OLDER_THAN"},
		"UPDATE_MIRRORS":                      {"PULL_LIMIT", "PUSH_LIMIT"},
		"REPO_HEALTH_CHECK":                   {"TIMEOUT", "ARGS"},
		"CHECK_REPO_STATS":                    nil,
		"UPDATE_MIGRATION_POSTER_ID":          nil,
		"SYNC_EXTERNAL_USERS":                 {"UPDATE_EXISTING"},
		"CLEANUP_ACTIONS":                     nil,
		"DELETED_BRANCHES_CLEANUP":            {"OLDER_THAN"},
		"CLEANUP_HOOK_TASK_TABLE":             {"CLEANUP_TYPE", "OLDER_THAN", "NUMBER_TO_KEEP"},
		"CLEANUP_PACKAGES":                    {"OLDER_THAN"},
		"SYNC_REPO_LICENSES":                  nil,
		"DELETE_INACTIVE_ACCOUNTS":            {"OLDER_THAN"},
		"DELETE_REPO_ARCHIVES":                nil,
		"GIT_GC_REPOS":                        {"TIMEOUT", "ARGS"},
		"RESYNC_ALL_SSHKEYS":                  nil,
		"RESYNC_ALL_SSHPRINCIPALS":            nil,
		"RESYNC_ALL_HOOKS":                    nil,
		"REINIT_MISSING_REPOS":                nil,
		"DELETE_MISSING_REPOS":                nil,
		"DELETE_GENERATED_REPOSITORY_AVATARS": nil,
		"DELETE_OLD_ACTIONS":                  {"OLDER_THAN"},
		"UPDATE_CHECKER":                      {"HTTP_ENDPOINT"},
		"DELETE_OLD_SYSTEM_NOTICES":           {"OLDER_THAN"},
		"GC_LFS":                              {"OLDER_THAN", "LAST_UPDATED_MORE_THAN_AGO", "NUMBER_TO_CHECK_PER_REPO", "PROPORTION_TO_CHECK_PER_REPO"},
		"REBUILD_ISSUE_INDEXER":               nil,
		"STOP_ZOMBIE_TASKS":                   nil,
		"STOP_ENDLESS_TASKS":                  nil,
		"CANCEL_ABANDONED_JOBS":               nil,
		"START_SCHEDULE_TASKS":                nil,
	}

	for task, extraKeys := range tasks {
		for _, key := range append([]string{
			"ENABLED",
			"RUN_AT_START",
			"NOTICE_ON_SUCCESS",
			"SCHEDULE",
		}, extraKeys...) {
			assert.Contains(t, documented, "CRON."+task+"."+key)
		}
	}
}

func TestAppExampleConfigDocumentsReindexerSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"DATABASE.DB_RETRIES",
		"DATABASE.DB_RETRY_BACKOFF",
		"DATABASE.REINDEXER_CREATE_DATABASE",
		"DATABASE.REINDEXER_LOGIN_TIMEOUT",
		"DATABASE.REINDEXER_MUTATION_BATCH_SIZE",
		"DATABASE.REINDEXER_NET_COMPRESSION",
		"DATABASE.REINDEXER_OBJECT_CACHE_BUDGET",
		"DATABASE.REINDEXER_POOL_SIZE",
		"DATABASE.REINDEXER_READ_RETRIES",
		"DATABASE.REINDEXER_REQUEST_TIMEOUT",
		"DATABASE.REINDEXER_SCHEMA_WORKERS",
		"DATABASE.REINDEXER_WRITE_RETRIES",
		"INDEXER.MAX_FILE_SIZE",
		"INDEXER.REPO_INDEXER_ENABLED",
		"INDEXER.REPO_INDEXER_EXCLUDE",
		"INDEXER.REPO_INDEXER_EXCLUDE_VENDORED",
		"INDEXER.REPO_INDEXER_INCLUDE",
		"INDEXER.REPO_INDEXER_REPO_TYPES",
		"INDEXER.STARTUP_TIMEOUT",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestContainerConfigTemplatesUseReindexerSettings(t *testing.T) {
	for _, path := range []string{
		filepath.Join("..", "..", "docker", "root", "etc", "templates", "app.ini"),
		filepath.Join("..", "..", "docker", "rootless", "etc", "templates", "app.ini"),
	} {
		t.Run(filepath.ToSlash(path), func(t *testing.T) {
			source, err := os.ReadFile(path)
			require.NoError(t, err)
			upperSource := strings.ToUpper(string(source))

			assert.NotContains(t, upperSource, "LOG_SQL")
			assert.NotContains(t, upperSource, "ISSUE_INDEXER_TYPE")
			assert.NotContains(t, upperSource, "REPO_INDEXER_TYPE")
			assert.Contains(t, upperSource, "REINDEXER_OBJECT_CACHE_BUDGET")
			assert.Contains(t, upperSource, "REINDEXER_SCHEMA_WORKERS")
			assert.Contains(t, upperSource, "REINDEXER_MUTATION_BATCH_SIZE")
			assert.Contains(t, upperSource, "DB_RETRY_BACKOFF")
		})
	}
}

func TestAppExampleConfigDocumentsUISurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"UI.AMBIGUOUS_UNICODE_DETECTION",
		"UI.CODE_COMMENT_LINES",
		"UI.CUSTOM_EMOJIS",
		"UI.DEFAULT_SHOW_FULL_NAME",
		"UI.DEFAULT_THEME",
		"UI.ENABLED_EMOJIS",
		"UI.EXPLORE_PAGING_DEFAULT_SORT",
		"UI.EXPLORE_PAGING_NUM",
		"UI.FEED_MAX_COMMIT_NUM",
		"UI.FEED_PAGING_NUM",
		"UI.FILE_ICON_THEME",
		"UI.FOLDER_ICON_THEME",
		"UI.GRAPH_MAX_COMMIT_NUM",
		"UI.ISSUE_PAGING_NUM",
		"UI.MAX_DISPLAY_FILE_SIZE",
		"UI.ONLY_SHOW_RELEVANT_REPOS",
		"UI.PREFERRED_TIMESTAMP_TENSE",
		"UI.REACTIONS",
		"UI.REACTION_MAX_USER_NUM",
		"UI.SEARCH_REPO_DESCRIPTION",
		"UI.SHOW_USER_EMAIL",
		"UI.SITEMAP_PAGING_NUM",
		"UI.THEMES",
		"UI.ADMIN.NOTICE_PAGING_NUM",
		"UI.ADMIN.ORG_PAGING_NUM",
		"UI.ADMIN.REPO_PAGING_NUM",
		"UI.ADMIN.USER_PAGING_NUM",
		"UI.CSV.MAX_FILE_SIZE",
		"UI.CSV.MAX_ROWS",
		"UI.META.AUTHOR",
		"UI.META.DESCRIPTION",
		"UI.META.KEYWORDS",
		"UI.NOTIFICATION.EVENT_SOURCE_UPDATE_TIME",
		"UI.NOTIFICATION.MAX_TIMEOUT",
		"UI.NOTIFICATION.MIN_TIMEOUT",
		"UI.NOTIFICATION.TIMEOUT_STEP",
		"UI.SVG.ENABLE_RENDER",
		"UI.USER.ORG_PAGING_NUM",
		"UI.USER.REPO_PAGING_NUM",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsGitSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"GIT.BRANCHES_RANGE_SIZE",
		"GIT.COMMITS_RANGE_SIZE",
		"GIT.DIFF_RENAME_SIMILARITY_THRESHOLD",
		"GIT.DISABLE_CORE_PROTECT_NTFS",
		"GIT.DISABLE_DIFF_HIGHLIGHT",
		"GIT.DISABLE_PARTIAL_CLONE",
		"GIT.ENABLE_AUTO_GIT_WIRE_PROTOCOL",
		"GIT.GC_ARGS",
		"GIT.HOME_PATH",
		"GIT.LARGE_OBJECT_THRESHOLD",
		"GIT.MAX_GIT_DIFF_FILES",
		"GIT.MAX_GIT_DIFF_LINES",
		"GIT.MAX_GIT_DIFF_LINE_CHARACTERS",
		"GIT.PATH",
		"GIT.PULL_REQUEST_PUSH_MESSAGE",
		"GIT.TIMEOUT.GC",
		"GIT.TIMEOUT.MIGRATE",
		"GIT.TIMEOUT.MIRROR",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsOAuth2Surface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"OAUTH2.CUSTOM_SCHEMES",
		"OAUTH2.DEFAULT_APPLICATIONS",
		"OAUTH2.JWT_CLAIM_ISSUER",
		"OAUTH2.JWT_SECRET",
		"OAUTH2.JWT_SIGNING_PRIVATE_KEY_FILE",
		"OAUTH2.MAX_TOKEN_LENGTH",
		"OAUTH2_CLIENT.ACCOUNT_LINKING",
		"OAUTH2_CLIENT.ENABLE_AUTO_REGISTRATION",
		"OAUTH2_CLIENT.OPENID_CONNECT_SCOPES",
		"OAUTH2_CLIENT.REGISTER_EMAIL_CONFIRM",
		"OAUTH2_CLIENT.UPDATE_AVATAR",
		"OAUTH2_CLIENT.USERNAME",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsLogSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"LOG.%(WRITERMODE).COLORIZE",
		"LOG.%(WRITERMODE).EXPRESSION",
		"LOG.%(WRITERMODE).FLAGS",
		"LOG.%(WRITERMODE).LEVEL",
		"LOG.%(WRITERMODE).MODE",
		"LOG.%(WRITERMODE).PREFIX",
		"LOG.ACCESS_LOG_TEMPLATE",
		"LOG.BUFFER_LEN",
		"LOG.CONN.ADDR",
		"LOG.CONN.PROTOCOL",
		"LOG.CONN.RECONNECT",
		"LOG.CONN.RECONNECT_ON_MSG",
		"LOG.CONSOLE.STDERR",
		"LOG.FILE.COMPRESS",
		"LOG.FILE.COMPRESSION_LEVEL",
		"LOG.FILE.DAILY_ROTATE",
		"LOG.FILE.FILE_NAME",
		"LOG.FILE.LOG_ROTATE",
		"LOG.FILE.MAX_DAYS",
		"LOG.FILE.MAX_SIZE_SHIFT",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsSecuritySurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"SECURITY.CONTENT_SECURITY_POLICY_GENERAL",
		"SECURITY.INTERNAL_TOKEN",
		"SECURITY.PASSWORD_HASH_ALGO",
		"SECURITY.RECORD_USER_SIGNUP_METADATA",
		"SECURITY.REVERSE_PROXY_LIMIT",
		"SECURITY.REVERSE_PROXY_LOGOUT_REDIRECT",
		"SECURITY.SECRET_KEY",
		"SECURITY.SUCCESSFUL_TOKENS_CACHE_SIZE",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsCamoAndCORSSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"CAMO.ALWAYS",
		"CAMO.ENABLED",
		"CAMO.HMAC_KEY",
		"CAMO.SERVER_URL",
		"CORS.ALLOW_CREDENTIALS",
		"CORS.ALLOW_DOMAIN",
		"CORS.ENABLED",
		"CORS.HEADERS",
		"CORS.MAX_AGE",
		"CORS.METHODS",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsServerSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"SERVER.ACME_ACCEPTTOS",
		"SERVER.ACME_CA_ROOT",
		"SERVER.ACME_DIRECTORY",
		"SERVER.ACME_EMAIL",
		"SERVER.ACME_URL",
		"SERVER.APP_TEMP_PATH",
		"SERVER.BUILTIN_SSH_SERVER_USER",
		"SERVER.DISABLE_SSH",
		"SERVER.ENABLE_ACME",
		"SERVER.LFS_ALLOW_PURE_SSH",
		"SERVER.LFS_HTTP_AUTH_EXPIRY",
		"SERVER.LFS_JWT_SECRET",
		"SERVER.LFS_JWT_SECRET_URI",
		"SERVER.LFS_LOCKS_PAGING_NUM",
		"SERVER.LFS_MAX_BATCH_SIZE",
		"SERVER.LFS_MAX_FILE_SIZE",
		"SERVER.LOCAL_USE_PROXY_PROTOCOL",
		"SERVER.MINIMUM_KEY_SIZE_CHECK",
		"SERVER.PORT_TO_REDIRECT",
		"SERVER.PPROF_DATA_PATH",
		"SERVER.PROXY_PROTOCOL_ACCEPT_UNKNOWN",
		"SERVER.PROXY_PROTOCOL_TLS_BRIDGING",
		"SERVER.REDIRECTOR_USE_PROXY_PROTOCOL",
		"SERVER.REDIRECT_OTHER_PORT",
		"SERVER.SSH_AUTHORIZED_KEYS_BACKUP",
		"SERVER.SSH_AUTHORIZED_PRINCIPALS_ALLOW",
		"SERVER.SSH_AUTHORIZED_PRINCIPALS_BACKUP",
		"SERVER.SSH_CREATE_AUTHORIZED_KEYS_FILE",
		"SERVER.SSH_CREATE_AUTHORIZED_PRINCIPALS_FILE",
		"SERVER.SSH_DOMAIN",
		"SERVER.SSH_EXPOSE_ANONYMOUS",
		"SERVER.SSH_LISTEN_HOST",
		"SERVER.SSH_LISTEN_PORT",
		"SERVER.SSH_PER_WRITE_PER_KB_TIMEOUT",
		"SERVER.SSH_PER_WRITE_TIMEOUT",
		"SERVER.SSH_ROOT_PATH",
		"SERVER.SSH_SERVER_CIPHERS",
		"SERVER.SSH_SERVER_HOST_KEYS",
		"SERVER.SSH_SERVER_KEY_EXCHANGES",
		"SERVER.SSH_SERVER_MACS",
		"SERVER.SSH_SERVER_USE_PROXY_PROTOCOL",
		"SERVER.SSH_TRUSTED_USER_CA_KEYS",
		"SERVER.SSH_TRUSTED_USER_CA_KEYS_FILENAME",
		"SERVER.SSH_USER",
		"SERVER.SSL_CIPHER_SUITES",
		"SERVER.SSL_CURVE_PREFERENCES",
		"SERVER.STATIC_CACHE_TIME",
		"SERVER.STATIC_ROOT_PATH",
		"SERVER.UNIX_SOCKET_PERMISSION",
		"SERVER.USE_SUB_URL_PATH",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsOperationsSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"ADMIN.DEFAULT_EMAIL_NOTIFICATIONS",
		"ADMIN.DISABLE_REGULAR_ORG_CREATION",
		"ADMIN.EXTERNAL_USER_DISABLE_FEATURES",
		"ADMIN.USER_DISABLED_FEATURES",
		"API.DEFAULT_GIT_TREES_PER_PAGE",
		"API.DEFAULT_MAX_BLOB_SIZE",
		"API.DEFAULT_MAX_RESPONSE_SIZE",
		"API.DEFAULT_PAGING_NUM",
		"API.ENABLE_SWAGGER",
		"API.MAX_RESPONSE_ITEMS",
		"METRICS.ENABLED",
		"METRICS.ENABLED_ISSUE_BY_LABEL",
		"METRICS.ENABLED_ISSUE_BY_REPOSITORY",
		"METRICS.TOKEN",
		"OPENID.BLACKLISTED_URIS",
		"OPENID.ENABLE_OPENID_SIGNIN",
		"OPENID.ENABLE_OPENID_SIGNUP",
		"OPENID.WHITELISTED_URIS",
		"OTHER.ENABLE_FEED",
		"OTHER.ENABLE_SITEMAP",
		"OTHER.SHOW_FOOTER_POWERED_BY",
		"OTHER.SHOW_FOOTER_TEMPLATE_LOAD_TIME",
		"OTHER.SHOW_FOOTER_VERSION",
		"PROXY.PROXY_ENABLED",
		"PROXY.PROXY_HOSTS",
		"PROXY.PROXY_URL",
		"QOS.ENABLED",
		"QOS.MAX_INFLIGHT",
		"QOS.MAX_WAITING",
		"QOS.TARGET_WAIT_TIME",
		"TIME.DEFAULT_UI_LOCATION",
		"WEBHOOK.PAGING_NUM",
		"WEBHOOK.PROXY_HOSTS",
		"WEBHOOK.PROXY_URL",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsBackgroundOperationsSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"GLOBAL_LOCK.SERVICE_CONN_STR",
		"GLOBAL_LOCK.SERVICE_TYPE",
		"LFS_CLIENT.BATCH_OPERATION_CONCURRENCY",
		"LFS_CLIENT.BATCH_SIZE",
		"MIRROR.DEFAULT_INTERVAL",
		"MIRROR.DISABLE_NEW_PULL",
		"MIRROR.DISABLE_NEW_PUSH",
		"MIRROR.ENABLED",
		"MIRROR.MIN_INTERVAL",
		"PROJECT.PROJECT_BOARD_BASIC_KANBAN_TYPE",
		"PROJECT.PROJECT_BOARD_BUG_TRIAGE_TYPE",
		"QUEUE.QUEUE_NAME",
		"QUEUE.SET_NAME",
		"SSH.MINIMUM_KEY_SIZES.DSA",
		"SSH.MINIMUM_KEY_SIZES.ECDSA",
		"SSH.MINIMUM_KEY_SIZES.ED25519",
		"SSH.MINIMUM_KEY_SIZES.RSA",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsMigrationsAndFederationSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"FEDERATION.ALGORITHMS",
		"FEDERATION.DIGEST_ALGORITHM",
		"FEDERATION.ENABLED",
		"FEDERATION.GET_HEADERS",
		"FEDERATION.MAX_SIZE",
		"FEDERATION.POST_HEADERS",
		"FEDERATION.SHARE_USER_STATISTICS",
		"MIGRATIONS.ALLOWED_DOMAINS",
		"MIGRATIONS.ALLOW_LOCALNETWORKS",
		"MIGRATIONS.BLOCKED_DOMAINS",
		"MIGRATIONS.MAX_ATTEMPTS",
		"MIGRATIONS.RETRY_BACKOFF",
		"MIGRATIONS.SKIP_TLS_VERIFY",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsMarkupAndPictureSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"MARKDOWN.CUSTOM_URL_SCHEMES",
		"MARKDOWN.ENABLE_MATH",
		"MARKDOWN.FILE_EXTENSIONS",
		"MARKDOWN.MATH_CODE_BLOCK_DETECTION",
		"MARKDOWN.RENDER_OPTIONS_COMMENT",
		"MARKDOWN.RENDER_OPTIONS_REPO_FILE",
		"MARKDOWN.RENDER_OPTIONS_WIKI",
		"MARKUP.ASCIIDOC.ENABLED",
		"MARKUP.ASCIIDOC.FILE_EXTENSIONS",
		"MARKUP.ASCIIDOC.IS_INPUT_FILE",
		"MARKUP.ASCIIDOC.NEED_POST_PROCESS",
		"MARKUP.ASCIIDOC.RENDER_COMMAND",
		"MARKUP.ASCIIDOC.RENDER_CONTENT_MODE",
		"MARKUP.ASCIIDOC.RENDER_CONTENT_SANDBOX",
		"MARKUP.MERMAID_MAX_SOURCE_CHARACTERS",
		"MARKUP.SANITIZER.1.ALLOW_ATTR",
		"MARKUP.SANITIZER.1.ELEMENT",
		"MARKUP.SANITIZER.1.REGEXP",
		"PICTURE.AVATAR_MAX_FILE_SIZE",
		"PICTURE.AVATAR_MAX_HEIGHT",
		"PICTURE.AVATAR_MAX_ORIGIN_SIZE",
		"PICTURE.AVATAR_MAX_WIDTH",
		"PICTURE.AVATAR_RENDERED_SIZE_FACTOR",
		"PICTURE.AVATAR_UPLOAD_PATH",
		"PICTURE.GRAVATAR_SOURCE",
		"PICTURE.REPOSITORY_AVATAR_FALLBACK",
		"PICTURE.REPOSITORY_AVATAR_FALLBACK_IMAGE",
		"PICTURE.REPOSITORY_AVATAR_UPLOAD_PATH",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsPackageStorageSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"ATTACHMENT.MINIO_ACCESS_KEY_ID",
		"ATTACHMENT.MINIO_BUCKET",
		"ATTACHMENT.MINIO_BUCKET_LOOKUP_TYPE",
		"ATTACHMENT.MINIO_CHECKSUM_ALGORITHM",
		"ATTACHMENT.MINIO_ENDPOINT",
		"ATTACHMENT.MINIO_IAM_ENDPOINT",
		"ATTACHMENT.MINIO_INSECURE_SKIP_VERIFY",
		"ATTACHMENT.MINIO_LOCATION",
		"ATTACHMENT.MINIO_SECRET_ACCESS_KEY",
		"ATTACHMENT.MINIO_USE_SSL",
		"PACKAGES.DEFAULT_RPM_SIGN_ENABLED",
		"PACKAGES.LIMIT_SIZE_ALPINE",
		"PACKAGES.LIMIT_SIZE_ARCH",
		"PACKAGES.LIMIT_SIZE_CARGO",
		"PACKAGES.LIMIT_SIZE_CHEF",
		"PACKAGES.LIMIT_SIZE_COMPOSER",
		"PACKAGES.LIMIT_SIZE_CONAN",
		"PACKAGES.LIMIT_SIZE_CONDA",
		"PACKAGES.LIMIT_SIZE_CRAN",
		"PACKAGES.LIMIT_SIZE_GO",
		"PACKAGES.LIMIT_SIZE_HELM",
		"PACKAGES.LIMIT_SIZE_MAVEN",
		"PACKAGES.LIMIT_SIZE_NUGET",
		"PACKAGES.LIMIT_SIZE_PUB",
		"PACKAGES.LIMIT_SIZE_RUBYGEMS",
		"PACKAGES.LIMIT_SIZE_SWIFT",
		"PACKAGES.LIMIT_SIZE_TERRAFORM_STATE",
		"PACKAGES.LIMIT_SIZE_VAGRANT",
		"STORAGE.PACKAGES.STORAGE_TYPE",
		"STORAGE.REPO-ARCHIVE.STORAGE_TYPE",
	} {
		assert.Contains(t, documented, key)
	}
}

func TestAppExampleConfigDocumentsMailSurface(t *testing.T) {
	documented := documentedExampleConfigKeys(t)

	for _, key := range []string{
		"EMAIL.INCOMING.DELETE_HANDLED_MESSAGE",
		"EMAIL.INCOMING.ENABLED",
		"EMAIL.INCOMING.HOST",
		"EMAIL.INCOMING.MAILBOX",
		"EMAIL.INCOMING.MAXIMUM_MESSAGE_SIZE",
		"EMAIL.INCOMING.PASSWORD",
		"EMAIL.INCOMING.PORT",
		"EMAIL.INCOMING.REPLY_TO_ADDRESS",
		"EMAIL.INCOMING.SKIP_TLS_VERIFY",
		"EMAIL.INCOMING.USERNAME",
		"EMAIL.INCOMING.USE_TLS",
		"MAILER.CLIENT_CERT_FILE",
		"MAILER.CLIENT_KEY_FILE",
		"MAILER.EMBED_ATTACHMENT_IMAGES",
		"MAILER.ENVELOPE_FROM",
		"MAILER.FROM_DISPLAY_NAME_FORMAT",
		"MAILER.HELO_HOSTNAME",
		"MAILER.SENDMAIL_ARGS",
		"MAILER.SENDMAIL_CONVERT_CRLF",
		"MAILER.SENDMAIL_PATH",
		"MAILER.SENDMAIL_TIMEOUT",
		"MAILER.USE_CLIENT_CERT",
	} {
		assert.Contains(t, documented, key)
	}
}

func documentedExampleConfigKeys(t *testing.T) map[string]struct{} {
	t.Helper()

	path := filepath.Join("..", "..", "custom", "conf", "app.example.ini")
	source, err := os.ReadFile(path)
	require.NoError(t, err)

	sectionPattern := regexp.MustCompile(`^;*\s*\[([^\]]+)\]\s*$`)
	keyPattern := regexp.MustCompile(`^;*\s*([A-Z][A-Z0-9_.-]*)\s*=`)
	section := "DEFAULT"
	documented := make(map[string]struct{})
	for sourceLine := range strings.SplitSeq(string(source), "\n") {
		line := strings.TrimSpace(sourceLine)
		if match := sectionPattern.FindStringSubmatch(line); match != nil {
			section = strings.ToUpper(match[1])
			continue
		}
		if match := keyPattern.FindStringSubmatch(line); match != nil {
			documented[section+"."+match[1]] = struct{}{}
		}
	}
	return documented
}