BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / config / config_test.go

config_test.go

config_test.go 6.1 KiB Download Raw
1package config
2
3import (
4 "os"
5 "path/filepath"
6 "testing"
7 "time"
8)
9
10func TestDefaults(t *testing.T) {
11 c, err := Load(filepath.Join(t.TempDir(), "geen.yml"))
12 if err != nil {
13 t.Fatal(err)
14 }
15 if c.ArchiveInterval.Duration != 24*time.Hour || c.RetentionDays != 30 || c.RateLimitKiB != 1024 || c.Listen != "0.0.0.0:8080" {
16 t.Fatalf("%+v", c)
17 }
18}
19
20func TestLoad(t *testing.T) {
21 p := filepath.Join(t.TempDir(), "c.yml")
22 _ = os.WriteFile(p, []byte("archive_interval: 7d\nretention_days: -1\nrate_limit_kib: -1\npublic_url: http://b:1\n"), 0o600)
23 c, err := Load(p)
24 if err != nil {
25 t.Fatal(err)
26 }
27 if c.ArchiveInterval.Duration != 7*24*time.Hour || c.RetentionDays != 0 || c.RateLimitKiB != 0 {
28 t.Fatalf("%+v", c)
29 }
30 _ = os.WriteFile(p, []byte("public_url: ftp://x\n"), 0o600)
31 if _, err := Load(p); err == nil {
32 t.Fatal("ftp geaccepteerd")
33 }
34 _ = os.WriteFile(p, []byte("archive_interval: soms\n"), 0o600)
35 if _, err := Load(p); err == nil {
36 t.Fatal("ongeldige duur geaccepteerd")
37 }
38 if _, err := os.Stat(p); err != nil {
39 t.Fatal(err)
40 }
41 if Example() == "" {
42 t.Fatal("geen voorbeeld")
43 }
44}
45
46func TestFieldsRoundTrip(t *testing.T) {
47 var c Config
48 c.Defaults()
49 for _, f := range Fields {
50 v := c.Get(f.Key)
51 if f.Key != "public_url" && v == "" {
52 t.Errorf("%s: leeg", f.Key)
53 }
54 if f.Readonly {
55 if err := c.Set(f.Key, v); err == nil {
56 t.Errorf("%s: readonly werd gewijzigd", f.Key)
57 }
58 continue
59 }
60 if err := c.Set(f.Key, v); err != nil && f.Key != "public_url" {
61 t.Errorf("%s=%q: %v", f.Key, v, err)
62 }
63 if got := c.Get(f.Key); got != v {
64 t.Errorf("%s: %q != %q", f.Key, got, v)
65 }
66 }
67 if c.Listen != "0.0.0.0:8080" {
68 t.Fatalf("standaardpoort %s", c.Listen)
69 }
70}
71
72func TestApplyIsAtomic(t *testing.T) {
73 var c Config
74 c.Defaults()
75 if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "nee"}); err == nil {
76 t.Fatal("fout verwacht")
77 }
78 if c.RetentionDays != 30 {
79 t.Fatal("half toegepast")
80 }
81 if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "7d", "public_url": "http://b:8080/"}); err != nil {
82 t.Fatal(err)
83 }
84 if c.RetentionDays != 7 || c.ArchiveInterval.Duration != 7*24*time.Hour || c.PublicURL != "http://b:8080" {
85 t.Fatalf("%+v", c)
86 }
87 if err := c.Apply(map[string]string{"data_dir": "/tmp"}); err == nil {
88 t.Fatal("data_dir mag niet")
89 }
90}
91
92func TestSettingsFile(t *testing.T) {
93 d := t.TempDir()
94 if err := SaveSettings(d, map[string]string{"retention_days": "3"}); err != nil {
95 t.Fatal(err)
96 }
97 m, err := LoadSettings(d)
98 if err != nil || m["retention_days"] != "3" {
99 t.Fatal(m, err)
100 }
101}
102
103func TestParsePublicURL(t *testing.T) {
104 ok := []string{
105 "",
106 "http://backup.lan:8080",
107 "https://backup.example.com",
108 "http://192.168.1.50:8080",
109 "http://127.0.0.1",
110 "http://[2001:db8::1]:8080",
111 "https://[::1]:443",
112 }
113 for _, s := range ok {
114 got, err := ParsePublicURL(s)
115 if err != nil {
116 t.Errorf("%q: %v", s, err)
117 }
118 if s != "" && got == "" {
119 t.Errorf("%q: leeg terug", s)
120 }
121 }
122 // Trailing slash gaat eraf.
123 got, err := ParsePublicURL("http://192.168.1.50:8080/")
124 if err != nil || got != "http://192.168.1.50:8080" {
125 t.Fatalf("slash: %q %v", got, err)
126 }
127 bad := []string{"ftp://x", "http://", "niet-een-url", "192.168.1.50:8080", "http://user:pass@host"}
128 for _, s := range bad {
129 if _, err := ParsePublicURL(s); err == nil {
130 t.Errorf("%q geaccepteerd", s)
131 }
132 }
133 var c Config
134 c.Defaults()
135 if err := c.Set("public_url", "http://192.168.1.50:8080"); err != nil {
136 t.Fatal(err)
137 }
138 if err := c.Set("public_url", "http://[2001:db8::1]:8080"); err != nil {
139 t.Fatal(err)
140 }
141 if err := c.Set("public_url", "ftp://x"); err == nil {
142 t.Fatal("ftp via Set")
143 }
144}
145
146func TestLoadRuntimeAndImportOnce(t *testing.T) {
147 root := t.TempDir()
148 data := filepath.Join(root, "data")
149 cfgPath := filepath.Join(root, "config.yml")
150 if err := os.WriteFile(cfgPath, []byte("listen: 127.0.0.1:9090\npublic_url: http://192.168.1.50:8080\ndata_dir: "+data+"\nretention_days: 7\n"), 0o600); err != nil {
151 t.Fatal(err)
152 }
153 c, err := LoadRuntime(Startup{ConfigPath: cfgPath}, nil)
154 if err != nil {
155 t.Fatal(err)
156 }
157 if c.DataDir != data || c.Listen != "127.0.0.1:9090" || c.PublicURL != "http://192.168.1.50:8080" || c.RetentionDays != 7 {
158 t.Fatalf("eerste import %+v", c)
159 }
160 if _, err := os.Stat(filepath.Join(data, SettingsFile)); err != nil {
161 t.Fatal("settings.yml ontbreekt")
162 }
163 if _, err := os.Stat(filepath.Join(data, LegacyImportMarker)); err != nil {
164 t.Fatal("marker ontbreekt")
165 }
166 // settings.yml wint; een latere wijziging in config.yml telt niet meer.
167 if err := os.WriteFile(cfgPath, []byte("listen: 0.0.0.0:1\npublic_url: http://other:1\ndata_dir: "+data+"\nretention_days: 99\n"), 0o600); err != nil {
168 t.Fatal(err)
169 }
170 if err := SaveSettings(data, map[string]string{"retention_days": "14", "listen": "127.0.0.1:9090", "public_url": "http://192.168.1.50:8080"}); err != nil {
171 t.Fatal(err)
172 }
173 c2, err := LoadRuntime(Startup{ConfigPath: cfgPath, DataDir: data}, nil)
174 if err != nil {
175 t.Fatal(err)
176 }
177 if c2.RetentionDays != 14 || c2.Listen != "127.0.0.1:9090" || c2.PublicURL != "http://192.168.1.50:8080" {
178 t.Fatalf("tweede start moet settings behouden %+v", c2)
179 }
180 // Zonder config.yml, alleen --data-dir.
181 empty := filepath.Join(root, "leeg")
182 c3, err := LoadRuntime(Startup{DataDir: empty, ConfigPath: filepath.Join(root, "bestaat-niet.yml")}, nil)
183 if err != nil {
184 t.Fatal(err)
185 }
186 if c3.DataDir != empty || c3.Listen != "0.0.0.0:8080" {
187 t.Fatalf("zonder config: %+v", c3)
188 }
189 // --data-dir wint van data_dir in het bestand.
190 other := filepath.Join(root, "other")
191 c4, err := LoadRuntime(Startup{ConfigPath: cfgPath, DataDir: other}, nil)
192 if err != nil {
193 t.Fatal(err)
194 }
195 if c4.DataDir != other {
196 t.Fatalf("flag moet winnen: %s", c4.DataDir)
197 }
198}
199
200func TestDataDirFlagWinsOverEnv(t *testing.T) {
201 root := t.TempDir()
202 flagDir := filepath.Join(root, "flag")
203 envDir := filepath.Join(root, "env")
204 d, _, err := (Startup{DataDir: flagDir, DataDirEnv: envDir}).Resolve()
205 if err != nil || d != flagDir {
206 t.Fatalf("flag %s err %v", d, err)
207 }
208 d, _, err = (Startup{DataDirEnv: envDir, ConfigPath: filepath.Join(root, "nee.yml")}).Resolve()
209 if err != nil || d != envDir {
210 t.Fatalf("env %s err %v", d, err)
211 }
212}