## Summary The generated configuration reference told a reader how to set each deployment option but not what the option accepts. Every entry carried the environment variable, CLI flag, YAML key, and default, while serpent's value type stayed in the source. A reader could not tell a `duration` from an `int`, or discover an enum's accepted values, without following the flag link into the CLI reference. - **Type** is now rendered for all 200 options from the serpent value. Enums expand into their choices (`- Type: `enum`, one of `password`, `awsiamrds``) rather than printing serpent's escaped `enum[a\|b]` spelling, which is meant for its own table output. - **Secrets** are now marked. The nine options carrying the `secret` annotation that `codersdk.IsSecretDeploymentOption` reads are deliberately excluded from YAML, so the page now says where to set them instead of leaving the omission unexplained. ## Correction to the issue DOCS-896 claimed the page showed a YAML key for secret options. It does not: all nine secret options have an empty `YAML` field, so the generator already omitted that bullet. The real gap was that nothing explained *why* the YAML key is missing. The page header and the per-option marker now cover it. ## Verification - `go test ./scripts/configdocgen` passes, with new cases for the enum-choice parsing, plain and nil value types, and the secret marker rendering exactly once for the annotated option. - Regenerated page has 200 `- Type:` lines for 200 rendered options and 9 secret markers. - `make lint/emdash`, markdownlint, `markdown-table-formatter`, and Vale are clean on the regenerated page. `golangci-lint` clean on the package. Full `make pre-commit` passed. <details> <summary>Local pre-push note</summary> The repository pre-push hook runs the full Go suite locally. In this workspace it segfaults the `make` process outright, and an isolated `make test` run produces ~1,000 failures unrelated to this change (embedded NATS servers failing to start within 10s, chatd state-machine tests), which reproduce independently of this diff. I verified the change with `go build ./...`, the package tests above, and the full pre-commit suite instead, and disabled the hook for this worktree only using its documented `git config coder.pre-push` knob, restoring the setting immediately after the push. No `--no-verify`. CI is the authority on the full suite here. </details> --- Generated with Coder Agents on behalf of @nickvigilante. Linear: [DOCS-896](https://linear.app/codercom/issue/DOCS-896/configdocgen-render-option-type-and-secret-status)
459 lines
17 KiB
Go
459 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"net/url"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/spf13/pflag"
|
|
|
|
"github.com/coder/serpent"
|
|
)
|
|
|
|
func TestSentenceCase(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{"lowercases trailing words", "Send Actor Headers", "Send actor headers"},
|
|
{"keeps trailing acronym", "Anthropic Base URL", "Anthropic base URL"},
|
|
{"keeps all-caps token", "Allow BYOK", "Allow BYOK"},
|
|
{"lowercases ordinary word", "Email Authentication", "Email authentication"},
|
|
{"keeps proper noun", "Trace Honeycomb API Key", "Trace Honeycomb API key"},
|
|
{"restores OpenID Connect", "OpenID Connect sign in text", "OpenID Connect sign in text"},
|
|
{"keeps leading mixed-case token", "SSH Keygen Algorithm", "SSH keygen algorithm"},
|
|
{"single lowercase word", "pprof", "pprof"},
|
|
{"feature name", "AI Gateway", "AI Gateway"},
|
|
{"longer feature name wins", "AI Gateway Proxy", "AI Gateway Proxy"},
|
|
{"feature name as whole title", "Template Builder", "Template Builder"},
|
|
{"feature name after leading word", "Disable Template Builder", "Disable Template Builder"},
|
|
{"leading symbol is not the first word", "⚠️ Dangerous", "⚠️ Dangerous"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := sentenceCase(tc.in); got != tc.want {
|
|
t.Errorf("sentenceCase(%q) = %q, want %q", tc.in, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStripLeadingSymbol(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{"emoji prefix", "⚠️ Dangerous", "Dangerous"},
|
|
{"no prefix", "Networking", "Networking"},
|
|
{"multiple leading symbols", "☢️ ⚠️ Dangerous", "Dangerous"},
|
|
{"symbol only", "⚠️", "⚠️"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := stripLeadingSymbol(tc.in); got != tc.want {
|
|
t.Errorf("stripLeadingSymbol(%q) = %q, want %q", tc.in, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStripGroupPrefix(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
aiGateway := serpent.Group{Name: "AI Gateway"}
|
|
email := serpent.Group{Name: "Email"}
|
|
emailAuth := serpent.Group{Name: "Email Authentication", Parent: &email}
|
|
introspection := serpent.Group{Name: "Introspection"}
|
|
healthCheck := serpent.Group{Name: "Health Check", Parent: &introspection}
|
|
networking := serpent.Group{Name: "Networking"}
|
|
derp := serpent.Group{Name: "DERP", Parent: &networking}
|
|
oauth2 := serpent.Group{Name: "OAuth2"}
|
|
github := serpent.Group{Name: "GitHub", Parent: &oauth2}
|
|
dangerous := serpent.Group{Name: "⚠️ Dangerous"}
|
|
|
|
cases := []struct {
|
|
name string
|
|
group *serpent.Group
|
|
want string
|
|
}{
|
|
// Space-prefixed names drop the group path.
|
|
{"AI Gateway Send Actor Headers", &aiGateway, "Send Actor Headers"},
|
|
{"DERP Config Path", &derp, "Config Path"},
|
|
{"OAuth2 GitHub Allow Everyone", &github, "Allow Everyone"},
|
|
// Colon-prefixed names drop up to the last ": ".
|
|
{"Email Auth: Identity", &emailAuth, "Identity"},
|
|
// A meaningful colon that is not a group separator is preserved.
|
|
{"Health Check Threshold: Database", &healthCheck, "Threshold: Database"},
|
|
// The Dangerous group's emoji name still matches its "DANGEROUS:" prefix.
|
|
{"DANGEROUS: Allow Path App Sharing", &dangerous, "Allow Path App Sharing"},
|
|
// Names that do not repeat the group are unchanged.
|
|
{"Access URL", &networking, "Access URL"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := stripGroupPrefix(tc.name, tc.group); got != tc.want {
|
|
t.Errorf("stripGroupPrefix(%q) = %q, want %q", tc.name, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestShortTitle(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
aiGateway := serpent.Group{Name: "AI Gateway"}
|
|
cases := []struct {
|
|
opt serpent.Option
|
|
want string
|
|
}{
|
|
{serpent.Option{Name: "AI Gateway Send Actor Headers", Group: &aiGateway}, "Send actor headers"},
|
|
{serpent.Option{Name: "AI Gateway Anthropic Base URL", Group: &aiGateway}, "Anthropic base URL"},
|
|
// No group: only sentence case applies.
|
|
{serpent.Option{Name: "Cache Directory"}, "Cache directory"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.opt.Name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := shortTitle(tc.opt); got != tc.want {
|
|
t.Errorf("shortTitle(%q) = %q, want %q", tc.opt.Name, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsDeprecated(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name string
|
|
opt serpent.Option
|
|
want bool
|
|
}{
|
|
{"description prefix", serpent.Option{Description: "Deprecated: use X instead."}, true},
|
|
{"description sentence", serpent.Option{Description: "Deprecated and ignored."}, true},
|
|
{"use instead", serpent.Option{UseInstead: []serpent.Option{{Name: "X"}}}, true},
|
|
{"active", serpent.Option{Description: "A normal option."}, false},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := isDeprecated(tc.opt); got != tc.want {
|
|
t.Errorf("isDeprecated(%s) = %v, want %v", tc.name, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEmphasizeDeprecation(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
// Description already starts with the marker: only the marker is bolded.
|
|
{"marker with sentence", "Deprecated and ignored.", "**Deprecated** and ignored."},
|
|
{"marker with colon", "Deprecated: use X.", "**Deprecated**: use X."},
|
|
// Description does not start with the marker (the UseInstead path): the
|
|
// marker is prepended.
|
|
{"no marker", "A normal description.", "**Deprecated.** A normal description."},
|
|
{"empty description", "", "Deprecated."},
|
|
// A bare marker with no trailing text is left unbolded (markdownlint MD036).
|
|
{"bare marker", "Deprecated", "Deprecated"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := emphasizeDeprecation(tc.in); got != tc.want {
|
|
t.Errorf("emphasizeDeprecation(%q) = %q, want %q", tc.in, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCollapse(t *testing.T) {
|
|
t.Parallel()
|
|
if got := collapse("a\n b\tc "); got != "a b c" {
|
|
t.Errorf("collapse() = %q, want %q", got, "a b c")
|
|
}
|
|
}
|
|
|
|
func TestSplitSentences(t *testing.T) {
|
|
t.Parallel()
|
|
tests := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{"single sentence", "One sentence.", "One sentence."},
|
|
{"two sentences", "First one. Second one.", "First one.\nSecond one."},
|
|
{"question and exclamation", "Why? Because! Done.", "Why?\nBecause!\nDone."},
|
|
{"closing quote or code span", "Set to `true`. Then restart.", "Set to `true`.\nThen restart."},
|
|
{"bold deprecation marker", "**Deprecated.** Use the new flag.", "**Deprecated.**\nUse the new flag."},
|
|
{"abbreviation", "Headers, e.g. X-Forwarded-For. Done.", "Headers, e.g. X-Forwarded-For.\nDone."},
|
|
{"lowercase continuation", "Use a dot. e.g. foo.", "Use a dot. e.g. foo."},
|
|
{"no list marker at line start", "Pick a value. 1. is not allowed.", "Pick a value. 1. is not allowed."},
|
|
{"dot inside a word", "See example.com for details.", "See example.com for details."},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := splitSentences(tt.in); got != tt.want {
|
|
t.Errorf("splitSentences(%q) = %q, want %q", tt.in, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestRenderDangerousWithDescription verifies the Caution alert uses the
|
|
// Dangerous group's own codersdk description when it has one, instead of the
|
|
// fallback copy.
|
|
func TestRenderDangerousWithDescription(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dangerous := serpent.Group{Name: "⚠️ Dangerous", YAML: "dangerous", Description: "Custom warning from codersdk."}
|
|
opts := serpent.OptionSet{
|
|
{Name: "DANGEROUS: Allow All Cors", Env: "CODER_DANGEROUS_ALLOW_ALL_CORS", Group: &dangerous, Description: "Allow all cross-origin requests."},
|
|
}
|
|
|
|
got := render(buildTree(opts))
|
|
if !strings.Contains(got, "> [!CAUTION]\n> Custom warning from codersdk.") {
|
|
t.Errorf("render() should use the group's own description in the Caution alert, got:\n%s", got)
|
|
}
|
|
if strings.Contains(got, dangerousCaution) {
|
|
t.Errorf("render() should not fall back to the default copy when a description is set, got:\n%s", got)
|
|
}
|
|
}
|
|
|
|
// TestRenderPipeline exercises buildTree and render end to end: section
|
|
// nesting and ordering, option skipping, deprecated sinking, and the per-option
|
|
// bullet list (environment variable, CLI flag anchor, YAML key, default).
|
|
func TestRenderPipeline(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
email := serpent.Group{Name: "Email", YAML: "email"}
|
|
emailAuth := serpent.Group{Name: "Email Authentication", YAML: "emailAuth", Parent: &email}
|
|
dangerous := serpent.Group{Name: "⚠️ Dangerous", YAML: "dangerous"}
|
|
|
|
opts := serpent.OptionSet{
|
|
// Hidden options and options with no env/flag/YAML are skipped.
|
|
{Name: "Hidden Option", Env: "CODER_HIDDEN", Hidden: true},
|
|
{Name: "Unsettable Option"},
|
|
// General section (no group).
|
|
{Name: "Access URL", Env: "CODER_ACCESS_URL", Flag: "access-url", Default: "https://example.com", Description: "The access URL."},
|
|
// A DefaultFn with no static Default renders the computed-at-runtime label.
|
|
{Name: "Cache Directory", Env: "CODER_CACHE_DIRECTORY", Flag: "cache-dir", DefaultFn: func() string { return "~/.cache/coder" }, Description: "The cache directory."},
|
|
// Deprecated via UseInstead: description does not start with "Deprecated".
|
|
{Name: "Email From", Env: "CODER_EMAIL_FROM", Flag: "email-from", YAML: "from", Group: &email, Description: "The sender address.", UseInstead: []serpent.Option{{Name: "Notifications Email From"}}},
|
|
// Active option with a flag shorthand.
|
|
{Name: "Email Smarthost", Env: "CODER_EMAIL_SMARTHOST", Flag: "email-smarthost", FlagShorthand: "s", YAML: "smarthost", Group: &email, Description: "The SMTP host."},
|
|
// Nested child section.
|
|
{Name: "Email Authentication Identity", Env: "CODER_EMAIL_AUTH_IDENTITY", YAML: "identity", Group: &emailAuth, Description: "The identity."},
|
|
// A Dangerous group sorts last regardless of alphabetical order.
|
|
{Name: "DANGEROUS: Allow All Cors", Env: "CODER_DANGEROUS_ALLOW_ALL_CORS", Flag: "dangerous-allow-all-cors", Group: &dangerous, Description: "Allow all cross-origin requests."},
|
|
}
|
|
|
|
got := render(buildTree(opts))
|
|
|
|
wantContains := []string{
|
|
"## General",
|
|
"### Access URL",
|
|
"- Environment variable: `CODER_ACCESS_URL`",
|
|
"- CLI flag: [`--access-url`](../../reference/cli/server/index.md#--access-url)",
|
|
"- Default value: `https://example.com`",
|
|
"## Email",
|
|
"### Smarthost",
|
|
// Flag shorthand is folded into the anchor to match the CLI reference.
|
|
"- CLI flag: [`--email-smarthost`](../../reference/cli/server/index.md#-s---email-smarthost)",
|
|
// YAML key is the dotted group path.
|
|
"- YAML key: `email.from`",
|
|
// Deprecated marker is prepended for the UseInstead path.
|
|
"**Deprecated.**\nThe sender address.",
|
|
// A DefaultFn with no static Default is labeled, not evaluated.
|
|
"- Default value: `(computed at runtime)`",
|
|
"### Email authentication",
|
|
"#### Identity",
|
|
"- YAML key: `email.emailAuth.identity`",
|
|
// The Dangerous group renders as its own section, emoji stripped, with
|
|
// a Caution alert (no description in codersdk, so the fallback copy)
|
|
// directly under the heading.
|
|
"## Dangerous",
|
|
"> [!CAUTION]\n> These options can break your deployment or weaken its security.",
|
|
}
|
|
for _, w := range wantContains {
|
|
if !strings.Contains(got, w) {
|
|
t.Errorf("render() missing %q\n---\n%s", w, got)
|
|
}
|
|
}
|
|
|
|
// General (rank -1) sorts before every other top-level section.
|
|
if i, j := strings.Index(got, "## General"), strings.Index(got, "## Email"); i < 0 || j < 0 || i > j {
|
|
t.Errorf("General should render before Email (got indexes %d, %d)", i, j)
|
|
}
|
|
// Active options sort before deprecated ones within a section.
|
|
if i, j := strings.Index(got, "### Smarthost"), strings.Index(got, "### From"); i < 0 || j < 0 || i > j {
|
|
t.Errorf("active option should render before deprecated option (got indexes %d, %d)", i, j)
|
|
}
|
|
// The Dangerous section sorts last among top-level sections.
|
|
if i, j := strings.Index(got, "## Email"), strings.Index(got, "## Dangerous"); i < 0 || j < 0 || i > j {
|
|
t.Errorf("Dangerous section should render last (got indexes %d, %d)", i, j)
|
|
}
|
|
// The Caution alert follows the Dangerous heading directly, before its
|
|
// first option.
|
|
if i, j, k := strings.Index(got, "## Dangerous"), strings.Index(got, "> [!CAUTION]"), strings.Index(got, "### Allow all cors"); i < 0 || j < 0 || k < 0 || (i >= j || j >= k) {
|
|
t.Errorf("Caution alert should render between the Dangerous heading and its options (got indexes %d, %d, %d)", i, j, k)
|
|
}
|
|
// Hidden and unsettable options never render.
|
|
if strings.Contains(got, "Hidden") {
|
|
t.Error("hidden option should be skipped")
|
|
}
|
|
if strings.Contains(got, "Unsettable") {
|
|
t.Error("option with no env/flag/YAML should be skipped")
|
|
}
|
|
}
|
|
|
|
func TestValueType(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name string
|
|
value pflag.Value
|
|
wantName string
|
|
wantChoices []string
|
|
}{
|
|
{"plain type", serpent.BoolOf(new(bool)), "bool", nil},
|
|
{"duration", serpent.DurationOf(new(time.Duration)), "duration", nil},
|
|
{
|
|
"enum lists its choices",
|
|
serpent.EnumOf(new(string), "password", "awsiamrds"),
|
|
"enum",
|
|
[]string{"password", "awsiamrds"},
|
|
},
|
|
{
|
|
"enum array lists its choices",
|
|
serpent.EnumArrayOf(new([]string), "read", "write"),
|
|
"enum-array",
|
|
[]string{"read", "write"},
|
|
},
|
|
{
|
|
"structured mapping uses a YAML type",
|
|
&serpent.Struct[map[string]string]{},
|
|
"YAML mapping",
|
|
nil,
|
|
},
|
|
{
|
|
"structured sequence uses a YAML type",
|
|
&serpent.Struct[[]string]{},
|
|
"YAML sequence",
|
|
nil,
|
|
},
|
|
{
|
|
"structured object uses a YAML type",
|
|
&serpent.Struct[struct{ Name string }]{},
|
|
"YAML object",
|
|
nil,
|
|
},
|
|
{"nil value has no type", nil, "", nil},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
gotName, gotChoices := valueType(serpent.Option{Value: tc.value})
|
|
if gotName != tc.wantName {
|
|
t.Errorf("valueType() name = %q, want %q", gotName, tc.wantName)
|
|
}
|
|
if !slices.Equal(gotChoices, tc.wantChoices) {
|
|
t.Errorf("valueType() choices = %v, want %v", gotChoices, tc.wantChoices)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestRenderTypeAndSecret covers the two fields the reference previously
|
|
// dropped: every option's value type, and the marker that keeps a secret out
|
|
// of a YAML configuration file.
|
|
func TestRenderTypeAndSecret(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
secret := serpent.Option{
|
|
Name: "Client Secret",
|
|
Description: "Client secret for the identity provider.",
|
|
Flag: "oidc-client-secret",
|
|
Env: "CODER_OIDC_CLIENT_SECRET",
|
|
Value: serpent.StringOf(new(string)),
|
|
Annotations: serpent.Annotations{}.Mark("secret", "true"),
|
|
}
|
|
plain := serpent.Option{
|
|
Name: "Access URL",
|
|
Description: "The URL the deployment is reachable at.",
|
|
Flag: "access-url",
|
|
Env: "CODER_ACCESS_URL",
|
|
YAML: "accessURL",
|
|
Value: serpent.URLOf(&url.URL{}),
|
|
}
|
|
|
|
enum := serpent.Option{
|
|
Name: "Database Authentication",
|
|
Description: "The database authentication method.",
|
|
Flag: "database-auth",
|
|
Env: "CODER_DATABASE_AUTH",
|
|
Value: serpent.EnumOf(new(string), "password", "awsiamrds"),
|
|
}
|
|
singleChoiceEnum := serpent.Option{
|
|
Name: "Budget Period",
|
|
Description: "The budget period.",
|
|
Flag: "budget-period",
|
|
Env: "CODER_BUDGET_PERIOD",
|
|
Value: serpent.EnumOf(new(string), "month"),
|
|
}
|
|
enumArray := serpent.Option{
|
|
Name: "Permissions",
|
|
Description: "The permissions to grant.",
|
|
Flag: "permissions",
|
|
Env: "CODER_PERMISSIONS",
|
|
Value: serpent.EnumArrayOf(new([]string), "read", "write"),
|
|
}
|
|
singleChoiceEnumArray := serpent.Option{
|
|
Name: "Allowed Permission",
|
|
Description: "The allowed permission.",
|
|
Flag: "allowed-permission",
|
|
Env: "CODER_ALLOWED_PERMISSION",
|
|
Value: serpent.EnumArrayOf(new([]string), "only"),
|
|
}
|
|
secretWithYAML := secret
|
|
secretWithYAML.Name = "Invalid Secret"
|
|
secretWithYAML.YAML = "invalidSecret"
|
|
secretWithoutEnv := secret
|
|
secretWithoutEnv.Name = "Secret Without Environment Variable"
|
|
secretWithoutEnv.Env = ""
|
|
|
|
got := render(buildTree(serpent.OptionSet{secret, plain, enum, singleChoiceEnum, enumArray, singleChoiceEnumArray, secretWithYAML, secretWithoutEnv}))
|
|
|
|
wantContains := []string{
|
|
"- Type: `string`",
|
|
"- Type: `url`",
|
|
"- Type: `enum`, one of `password`, `awsiamrds`",
|
|
"- Type: `enum`, must be `month`",
|
|
"- Type: `enum-array`, each value must be one of `read`, `write`",
|
|
"- Type: `enum-array`, each value must be `only`",
|
|
"- Holds a secret: Coder never writes this option to a YAML configuration file.\n Set it through the environment variable above.",
|
|
"### Secret without environment variable\n\nClient secret for the identity provider.\n\n- Type: `string`\n- CLI flag: [`--oidc-client-secret`](../../reference/cli/server/index.md#--oidc-client-secret)\n- Holds a secret: Coder never writes this option to a YAML configuration file.\n",
|
|
}
|
|
for _, w := range wantContains {
|
|
if !strings.Contains(got, w) {
|
|
t.Errorf("render() missing %q\n---\n%s", w, got)
|
|
}
|
|
}
|
|
|
|
if n := strings.Count(got, "Holds a secret"); n != 3 {
|
|
t.Errorf("secret marker rendered %d times, want 3", n)
|
|
}
|
|
}
|