1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
package cli
import (
"context"
"errors"
"os"
"path/filepath"
"strings"
"testing"
)
// clearGlobalEnv neutralizes the BUNNY_ env fallbacks so a test controls
// resolution entirely through flags.
func clearGlobalEnv(t *testing.T) {
t.Helper()
for _, k := range []string{"BUNNY_ZONE", "BUNNY_ENDPOINT", "BUNNY_ACCESS_KEY_FILE", "BUNNY_ACCESS_KEY"} {
t.Setenv(k, "")
}
}
func writeKeyFile(t *testing.T) string {
t.Helper()
p := filepath.Join(t.TempDir(), "key")
if err := os.WriteFile(p, []byte("secret\n"), 0o600); err != nil {
t.Fatal(err)
}
return p
}
func runMain(args []string) error {
return newMainCommand().Run(context.Background(), args)
}
func TestMainMissingSubcommand(t *testing.T) {
clearGlobalEnv(t)
captureLogs(t)
var ue usageError
if err := runMain(nil); !errors.As(err, &ue) {
t.Fatalf("expected usageError, got %v", err)
}
}
func TestMainMissingZone(t *testing.T) {
clearGlobalEnv(t)
captureLogs(t)
var ue usageError
err := runMain([]string{"push"})
if !errors.As(err, &ue) || !strings.Contains(err.Error(), "zone") {
t.Fatalf("expected missing-zone usageError, got %v", err)
}
}
func TestMainMissingAccessKey(t *testing.T) {
clearGlobalEnv(t)
captureLogs(t)
var ue usageError
err := runMain([]string{"--zone", "z", "push"})
if !errors.As(err, &ue) || !strings.Contains(err.Error(), "access key") {
t.Fatalf("expected missing-access-key usageError, got %v", err)
}
}
func TestMainUnknownSubcommand(t *testing.T) {
clearGlobalEnv(t)
captureLogs(t)
kf := writeKeyFile(t)
var ue usageError
err := runMain([]string{"--zone", "z", "--access-key-file", kf, "frob"})
if !errors.As(err, &ue) || !strings.Contains(err.Error(), "unknown subcommand") {
t.Fatalf("expected unknown-subcommand usageError, got %v", err)
}
}
func TestMainDispatchesToPrune(t *testing.T) {
clearGlobalEnv(t)
captureLogs(t)
kf := writeKeyFile(t)
// A fully-resolved global set reaches dispatch; the missing archive surfaces a
// plain (non-usage) error, proving parse + validation + dispatch worked.
err := runMain([]string{"--zone", "z", "--access-key-file", kf, "prune", "no-such.tgz"})
if err == nil || !strings.Contains(err.Error(), "open archive") {
t.Fatalf("expected prune dispatch error, got %v", err)
}
}
func TestMainAccessKeyFromEnv(t *testing.T) {
clearGlobalEnv(t)
captureLogs(t)
t.Setenv("BUNNY_ACCESS_KEY", "literalkey")
// With no --access-key-file, the literal BUNNY_ACCESS_KEY resolves the key
// and resolution reaches prune.
err := runMain([]string{"--zone", "z", "prune", "no-such.tgz"})
if err == nil || !strings.Contains(err.Error(), "open archive") {
t.Fatalf("expected prune dispatch error (env access key resolved), got %v", err)
}
}
func TestMainZoneFromEnv(t *testing.T) {
clearGlobalEnv(t)
captureLogs(t)
t.Setenv("BUNNY_ZONE", "envzone")
kf := writeKeyFile(t)
// With zone supplied via env, resolution succeeds and reaches prune.
err := runMain([]string{"--access-key-file", kf, "prune", "no-such.tgz"})
if err == nil || !strings.Contains(err.Error(), "open archive") {
t.Fatalf("expected prune dispatch error (env zone resolved), got %v", err)
}
}
func TestLookupEnv(t *testing.T) {
t.Setenv("BUNNY_TEST_LOOKUP", "value")
if got := lookupEnv("BUNNY_TEST_LOOKUP", "fallback"); got != "value" {
t.Fatalf("set env: got %q", got)
}
t.Setenv("BUNNY_TEST_LOOKUP", "")
if got := lookupEnv("BUNNY_TEST_LOOKUP", "fallback"); got != "fallback" {
t.Fatalf("empty env should fall back: got %q", got)
}
}
|
